Danger

DANGER WILL ROBINSON! This chapter is still UNDER CONSTRUCTION. It is DEFINITELY full of mistakes and may be completely different when I am done editing it though most of the code should work

functions: tests and solutions

functions: tests

the code in functions/tests/test_functions.py from functions

  1import src.functions
  2import unittest
  3
  4
  5class TestFunctions(unittest.TestCase):
  6
  7    def test_why_use_a_function(self):
  8        def add_x(x=3, y=0):
  9            return x + y
 10
 11        self.assertEqual(add_x(y=0), 3)
 12        self.assertEqual(add_x(y=1), 4)
 13        self.assertEqual(add_x(y=2), 5)
 14        self.assertEqual(add_x(y=3), 6)
 15        self.assertEqual(add_x(y=4), 7)
 16        self.assertEqual(add_x(y=5), 8)
 17        self.assertEqual(add_x(y=6), 9)
 18        self.assertEqual(add_x(y=7), 10)
 19        self.assertEqual(add_x(y=8), 11)
 20        self.assertEqual(add_x(y=9), 12)
 21
 22    def test_making_a_function_w_pass(self):
 23        self.assertIsNone(src.functions.w_pass())
 24
 25    def test_making_a_function_w_return(self):
 26        self.assertIsNone(src.functions.w_return())
 27
 28    def test_making_a_function_w_return_none(self):
 29        self.assertIsNone(src.functions.w_return_none())
 30
 31    def test_what_happens_after_a_function_returns(self):
 32        self.assertIsNone(src.functions.return_is_last())
 33
 34    def test_constant_function(self):
 35        self.assertEqual(
 36            src.functions.constant(),
 37            'the same thing'
 38        )
 39
 40    def test_identity_function(self):
 41        self.assertIsNone(src.functions.identity(None))
 42        self.assertEqual(src.functions.identity(object), object)
 43
 44    def test_functions_w_positional_arguments(self):
 45        self.assertEqual(
 46            src.functions.w_positional_arguments('first', 'last'),
 47            ('first', 'last')
 48        )
 49        self.assertEqual(
 50            src.functions.w_positional_arguments('last', 'first'),
 51            ('last', 'first')
 52        )
 53
 54    def test_functions_w_keyword_arguments(self):
 55        self.assertEqual(
 56            src.functions.w_keyword_arguments(
 57                first_input='first', last_input='last',
 58            ),
 59            ('first', 'last')
 60        )
 61        self.assertEqual(
 62            src.functions.w_keyword_arguments(
 63                last_input='last', first_input='first',
 64            ),
 65            ('first', 'last')
 66        )
 67        self.assertEqual(
 68            src.functions.w_keyword_arguments('last', 'first'),
 69            ('last', 'first')
 70        )
 71
 72    def test_functions_w_positional_and_keyword_arguments(self):
 73        self.assertEqual(
 74            src.functions.w_positional_and_keyword_arguments(
 75                'first', last_input='last',
 76            ),
 77            ('first', 'last')
 78        )
 79
 80    def test_functions_w_default_arguments(self):
 81        self.assertEqual(
 82            src.functions.w_default_arguments('jane'),
 83            ('jane', 'doe')
 84        )
 85        self.assertEqual(
 86            src.functions.w_default_arguments('joe', 'blow'),
 87            ('joe', 'blow')
 88        )
 89
 90    def test_functions_w_unknown_arguments(self):
 91        self.assertEqual(
 92            src.functions.w_unknown_arguments(
 93                0, 1, 2, 3, a=4, b=5, c=6, d=7,
 94            ),
 95            ((0, 1, 2, 3), {'a': 4, 'b': 5, 'c': 6, 'd': 7})
 96        )
 97        self.assertEqual(
 98            src.functions.w_unknown_arguments(0, 1, 2, 3),
 99            ((0, 1, 2, 3), {})
100        )
101        self.assertEqual(
102            src.functions.w_unknown_arguments(a=4, b=5, c=6, d=7),
103            ((), dict(a=4, b=5, c=6, d=7))
104        )
105        self.assertEqual(
106            src.functions.w_unknown_arguments(),
107            ((), {})
108        )
109
110
111# Exceptions seen
112# AssertionError
113# NameError
114# AttributeError
115# TypeError
116# SyntaxError

functions: solutions

the solutions in functions/src/functions.py from functions

 1def w_pass():
 2    pass
 3
 4
 5def w_return():
 6    return
 7
 8
 9def w_return_none():
10    return None
11
12
13def return_is_last():
14    return None
15    return 'will not run'
16
17
18def constant():
19    return 'the same thing'
20
21
22def identity(the_input):
23    return the_input
24
25
26def w_positional_arguments(first_input, last_input):
27    return first_input, last_input
28
29
30def w_keyword_arguments(first_input, last_input):
31    return first_input, last_input
32
33
34def w_positional_and_keyword_arguments(first_input, last_input):
35    return first_input, last_input
36
37
38def w_default_arguments(first_name, last_name='doe'):
39    return first_name, last_name
40
41
42def w_unknown_arguments(*positional_arguments, **keyword_arguments):
43    return positional_arguments, keyword_arguments

functions 2: tests

the code in functions/tests/test_functions.py from functions 2

  1import src.functions
  2import unittest
  3
  4
  5class TestFunctions(unittest.TestCase):
  6
  7    def test_why_use_a_function(self):
  8        def add(x=3, y=0):
  9            return x + y
 10
 11        x = 4
 12        y = 0
 13        self.assertEqual(add(x, y), x+y)
 14        y = 1
 15        self.assertEqual(add(x, y), x+y)
 16        y = 2
 17        self.assertEqual(add(x, y), x+y)
 18        y = 3
 19        self.assertEqual(add(x, y), x+y)
 20        y = 4
 21        self.assertEqual(add(x, y), x+y)
 22        y = 5
 23        self.assertEqual(add(x, y), x+y)
 24        y = 6
 25        self.assertEqual(add(x, y), x+y)
 26        y = 7
 27        self.assertEqual(add(x, y), x+y)
 28        y = 8
 29        self.assertEqual(add(x, y), x+y)
 30
 31    def test_making_a_function_w_pass(self):
 32        self.assertIsNone(src.functions.w_pass())
 33
 34    def test_making_a_function_w_return(self):
 35        self.assertIsNone(src.functions.w_return())
 36
 37    def test_making_a_function_w_return_none(self):
 38        self.assertIsNone(src.functions.w_return_none())
 39
 40    def test_what_happens_after_a_function_returns(self):
 41        self.assertIsNone(src.functions.return_is_last())
 42
 43    def test_constant_function(self):
 44        self.assertEqual(
 45            src.functions.constant(),
 46            'the same thing'
 47        )
 48
 49    def test_identity_function(self):
 50        self.assertIsNone(src.functions.identity(None))
 51        self.assertEqual(src.functions.identity(object), object)
 52
 53    def test_functions_w_positional_arguments(self):
 54        self.assertEqual(
 55            src.functions.w_positional_arguments('first', 'last'),
 56            ('first', 'last')
 57        )
 58        self.assertEqual(
 59            src.functions.w_positional_arguments('last', 'first'),
 60            ('last', 'first')
 61        )
 62
 63    def test_functions_w_keyword_arguments(self):
 64        self.assertEqual(
 65            src.functions.w_keyword_arguments(
 66                first_input='first', last_input='last',
 67            ),
 68            ('first', 'last')
 69        )
 70        self.assertEqual(
 71            src.functions.w_keyword_arguments(
 72                last_input='last', first_input='first',
 73            ),
 74            ('first', 'last')
 75        )
 76        self.assertEqual(
 77            src.functions.w_keyword_arguments('last', 'first'),
 78            ('last', 'first')
 79        )
 80
 81    def test_functions_w_positional_and_keyword_arguments(self):
 82        self.assertEqual(
 83            src.functions.w_positional_and_keyword_arguments(
 84                'first', last_input='last',
 85            ),
 86            ('first', 'last')
 87        )
 88
 89    def test_functions_w_default_arguments(self):
 90        self.assertEqual(
 91            src.functions.w_default_arguments('jane'),
 92            ('jane', 'doe')
 93        )
 94        self.assertEqual(
 95            src.functions.w_default_arguments('joe', 'blow'),
 96            ('joe', 'blow')
 97        )
 98
 99    def test_functions_w_unknown_arguments(self):
100        self.assertEqual(
101            src.functions.w_unknown_arguments(
102                0, 1, 2, 3, a=4, b=5, c=6, d=7,
103            ),
104            ((0, 1, 2, 3, ), {'a': 4, 'b': 5, 'c': 6, 'd': 7})
105        )
106        self.assertEqual(
107            src.functions.w_unknown_arguments(0, 1, 2, 3),
108            ((0, 1, 2, 3), {})
109        )
110        self.assertEqual(
111            src.functions.w_unknown_arguments(a=4, b=5, c=6, d=7),
112            ((), dict(a=4, b=5, c=6, d=7))
113        )
114        self.assertEqual(
115            src.functions.w_unknown_arguments(),
116            ((), {})
117        )
118
119
120# Exceptions seen
121# AssertionError
122# NameError
123# AttributeError
124# TypeError

functions 3: solutions

the solutions in functions/tests/test_functions.py from functions 3

  1import src.functions
  2import unittest
  3
  4
  5class TestFunctions(unittest.TestCase):
  6
  7    def test_why_use_a_function(self):
  8        def add(x, y):
  9            return x + y
 10
 11        for x in range(0, 9):
 12            for y in range(0, 9):
 13                with self.subTest(y=y):
 14                    self.assertEqual(add(x, y), x+y)
 15
 16    def test_making_a_function_w_pass(self):
 17        self.assertIsNone(src.functions.w_pass())
 18
 19    def test_making_a_function_w_return(self):
 20        self.assertIsNone(src.functions.w_return())
 21
 22    def test_making_a_function_w_return_none(self):
 23        self.assertIsNone(src.functions.w_return_none())
 24
 25    def test_what_happens_after_a_function_returns(self):
 26        self.assertIsNone(src.functions.return_is_last())
 27
 28    def test_constant_function(self):
 29        self.assertEqual(
 30            src.functions.constant(),
 31            'the same thing'
 32        )
 33
 34    def test_identity_function(self):
 35        self.assertIsNone(src.functions.identity(None))
 36        self.assertEqual(src.functions.identity(object), object)
 37
 38    def test_functions_w_positional_arguments(self):
 39        self.assertEqual(
 40            src.functions.w_positional_arguments('first', 'last'),
 41            ('first', 'last')
 42        )
 43        self.assertEqual(
 44            src.functions.w_positional_arguments('last', 'first'),
 45            ('last', 'first')
 46        )
 47
 48    def test_functions_w_keyword_arguments(self):
 49        self.assertEqual(
 50            src.functions.w_keyword_arguments(
 51                first_input='first', last_input='last',
 52            ),
 53            ('first', 'last')
 54        )
 55        self.assertEqual(
 56            src.functions.w_keyword_arguments(
 57                last_input='last', first_input='first',
 58            ),
 59            ('first', 'last')
 60        )
 61        self.assertEqual(
 62            src.functions.w_keyword_arguments('last', 'first'),
 63            ('last', 'first')
 64        )
 65
 66    def test_functions_w_positional_and_keyword_arguments(self):
 67        self.assertEqual(
 68            src.functions.w_positional_and_keyword_arguments(
 69                'first', last_input='last',
 70            ),
 71            ('first', 'last')
 72        )
 73
 74    def test_functions_w_default_arguments(self):
 75        self.assertEqual(
 76            src.functions.w_default_arguments('jane'),
 77            ('jane', 'doe')
 78        )
 79        self.assertEqual(
 80            src.functions.w_default_arguments('joe', 'blow'),
 81            ('joe', 'blow')
 82        )
 83
 84    def test_functions_w_unknown_arguments(self):
 85        self.assertEqual(
 86            src.functions.w_unknown_arguments(
 87                0, 1, 2, 3, a=4, b=5, c=6, d=7,
 88            ),
 89            ((0, 1, 2, 3, ), {'a': 4, 'b': 5, 'c': 6, 'd': 7})
 90        )
 91        self.assertEqual(
 92            src.functions.w_unknown_arguments(0, 1, 2, 3),
 93            ((0, 1, 2, 3), {})
 94        )
 95        self.assertEqual(
 96            src.functions.w_unknown_arguments(a=4, b=5, c=6, d=7),
 97            ((), dict(a=4, b=5, c=6, d=7))
 98        )
 99        self.assertEqual(
100            src.functions.w_unknown_arguments(),
101            ((), {})
102        )
103
104
105# Exceptions seen
106# AssertionError
107# NameError
108# AttributeError
109# TypeError