functions: tests and solutions

functions: tests

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