data structures: list comprehensions: tests and solutions

list comprehensions tests

the code from list_comprehensions/tests/test_list_comprehensions.py from list comprehensions

  1import random
  2import src.list_comprehensions
  3import unittest
  4
  5
  6def process(number):
  7    return number ** 2
  8
  9
 10def condition(number):
 11    return number % 2 == 0
 12
 13
 14class TestListComprehensions(unittest.TestCase):
 15
 16    def setUp(self):
 17        self.a_list = []
 18        self.iterable = range(0, random.randint(2, 1000))
 19
 20    def test_making_a_list_w_a_for_loop(self):
 21        for number in self.iterable:
 22            self.a_list.append(number)
 23
 24        self.assertEqual(self.a_list, list(self.iterable))
 25        self.assertEqual(
 26            src.list_comprehensions.a_for_loop(self.iterable),
 27            self.a_list
 28        )
 29
 30    def test_making_a_list_w_extend(self):
 31        self.assertIsNone(self.a_list.extend(self.iterable))
 32        self.assertEqual(self.a_list, list(self.iterable))
 33
 34    def test_making_a_list_w_a_list_comprehension(self):
 35        self.assertEqual(
 36            list(self.iterable),
 37            [item for item in self.iterable]
 38        )
 39        self.assertEqual(
 40            src.list_comprehensions.a_list_comprehension(self.iterable),
 41            [item for item in self.iterable]
 42        )
 43
 44    def test_making_a_list_w_conditions(self):
 45        even_numbers, odd_numbers = [], []
 46        for item in self.iterable:
 47            if condition(item):
 48                even_numbers.append(item)
 49            else:
 50                odd_numbers.append(item)
 51
 52        self.assertEqual(
 53            even_numbers,
 54            [item for item in self.iterable if condition(item)]
 55        )
 56        self.assertEqual(
 57            src.list_comprehensions.get_even_numbers(self.iterable),
 58            [item for item in self.iterable if condition(item)]
 59        )
 60        self.assertEqual(
 61            odd_numbers,
 62            [item for item in self.iterable if not condition(item)]
 63        )
 64        self.assertEqual(
 65            src.list_comprehensions.get_odd_numbers(self.iterable),
 66            [item for item in self.iterable if not condition(item)]
 67        )
 68
 69    def test_making_a_list_w_processes(self):
 70        square_club = []
 71        for item in self.iterable:
 72            square_club.append(process(item))
 73
 74        self.assertEqual(
 75            square_club,
 76            [process(item) for item in self.iterable]
 77        )
 78        self.assertEqual(
 79            src.list_comprehensions.square(self.iterable),
 80            [process(item) for item in self.iterable]
 81        )
 82
 83    def test_making_a_list_w_processes_and_conditions(self):
 84        even_squares, odd_squares = [], []
 85        for item in self.iterable:
 86            item = process(item)
 87            if condition(item):
 88                even_squares.append(item)
 89            else:
 90                odd_squares.append(item)
 91
 92        self.assertEqual(
 93            even_squares,
 94            [process(item) for item in self.iterable if condition(item)]
 95        )
 96        self.assertEqual(
 97            odd_squares,
 98            [process(item) for item in self.iterable if not condition(item)]
 99        )
100
101
102# Exceptions seen
103# AssertionError
104# NameError
105# AttributeError
106# TypeError

how to make a calculator 6: tests

the code from calculator/tests/test_calculator.py from how to make a calculator 6

  1import random
  2import src.calculator
  3import unittest
  4
  5
  6def a_random_number():
  7    return random.triangular(-1000.0, 1000.0)
  8
  9
 10class TestCalculator(unittest.TestCase):
 11
 12    def setUp(self):
 13        self.random_first_number = a_random_number()
 14        self.random_second_number = a_random_number()
 15
 16    def test_addition(self):
 17        self.assertEqual(
 18            src.calculator.add(
 19                self.random_first_number,
 20                self.random_second_number
 21            ),
 22            self.random_first_number+self.random_second_number
 23        )
 24
 25    def test_subtraction(self):
 26        self.assertEqual(
 27            src.calculator.subtract(
 28                self.random_first_number,
 29                self.random_second_number
 30            ),
 31            self.random_first_number-self.random_second_number
 32        )
 33
 34    def test_multiplication(self):
 35        self.assertEqual(
 36            src.calculator.multiply(
 37                self.random_first_number,
 38                self.random_second_number
 39            ),
 40            self.random_first_number*self.random_second_number
 41        )
 42
 43    def test_division(self):
 44        try:
 45            self.assertEqual(
 46                src.calculator.divide(
 47                    self.random_first_number,
 48                    self.random_second_number
 49                ),
 50                self.random_first_number/self.random_second_number
 51            )
 52        except ZeroDivisionError:
 53            self.assertEqual(
 54                src.calculator.divide(self.random_first_number, 0),
 55                'brmph?! I cannot divide by 0. Try again...'
 56            )
 57
 58    def test_calculator_w_list_items(self):
 59        two_numbers = [
 60            self.random_first_number,
 61            self.random_second_number
 62        ]
 63
 64        self.assertEqual(
 65            src.calculator.add(
 66                two_numbers[0],
 67                two_numbers[1]
 68            ),
 69            self.random_first_number+self.random_second_number
 70        )
 71        self.assertEqual(
 72            src.calculator.divide(
 73                two_numbers[-2],
 74                two_numbers[-1]
 75            ),
 76            self.random_first_number/self.random_second_number
 77        )
 78        self.assertEqual(
 79            src.calculator.multiply(
 80                two_numbers[1],
 81                two_numbers[-1]
 82            ),
 83            self.random_second_number*self.random_second_number
 84        )
 85        self.assertEqual(
 86            src.calculator.subtract(
 87                two_numbers[-2],
 88                two_numbers[0]
 89            ),
 90            self.random_first_number-self.random_first_number
 91        )
 92        self.assertEqual(
 93            src.calculator.add(*two_numbers),
 94            self.random_first_number+self.random_second_number
 95        )
 96        self.assertEqual(
 97            src.calculator.divide(*two_numbers),
 98            self.random_first_number/self.random_second_number
 99        )
100        self.assertEqual(
101            src.calculator.multiply(*two_numbers),
102            self.random_first_number*self.random_second_number
103        )
104        self.assertEqual(
105            src.calculator.subtract(*two_numbers),
106            self.random_first_number-self.random_second_number
107        )
108
109    def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):
110        not_two_numbers = [0, 1, 2]
111
112        with self.assertRaises(TypeError):
113            src.calculator.add(*not_two_numbers)
114        with self.assertRaises(TypeError):
115            src.calculator.divide(*not_two_numbers)
116        with self.assertRaises(TypeError):
117            src.calculator.multiply(*not_two_numbers)
118        with self.assertRaises(TypeError):
119            src.calculator.subtract(*not_two_numbers)
120
121    def test_calculator_sends_message_when_input_is_not_a_number(self):
122        error_message = 'brmph?! Numbers only. Try again...'
123
124        [
125            self.assertEqual(
126                src.calculator.add(data_type, a_random_number()),
127                error_message
128            ) for data_type in (
129                None,
130                True, False,
131                str(), 'text',
132                tuple(), (0, 1, 2, 'n'),
133                list(), [0, 1, 2, 'n'],
134                set(), {0, 1, 2, 'n'},
135                dict(), {'key': 'value'},
136            )
137        ]
138
139        for data_type in (
140            None,
141            True, False,
142            str(), 'text',
143            tuple(), (0, 1, 2, 'n'),
144            list(), [0, 1, 2, 'n'],
145            set(), {0, 1, 2, 'n'},
146            dict(), {'key': 'value'},
147        ):
148            with self.subTest(data_type=data_type):
149                self.assertEqual(
150                    src.calculator.add(
151                        data_type, a_random_number()
152                    ),
153                    error_message
154                )
155                self.assertEqual(
156                    src.calculator.divide(
157                        data_type, a_random_number()
158                    ),
159                    error_message
160                )
161                self.assertEqual(
162                    src.calculator.multiply(
163                        data_type, a_random_number()
164                    ),
165                    error_message
166                )
167                self.assertEqual(
168                    src.calculator.subtract(
169                        data_type, a_random_number()
170                    ),
171                    error_message
172                )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError

how to make a calculator 6: solutions

the solutions in calculator/src/calculator.py from how to make a calculator 6

 1def numbers_only(function):
 2    def decorator(first_input, second_input):
 3        bad_data_types = (str, list, bool)
 4        error_message = 'brmph?! Numbers only. Try again...'
 5
 6        for value in (first_input, second_input):
 7            if (
 8                value is None
 9                or
10                isinstance(value, bad_data_types)
11            ):
12                return error_message
13
14        try:
15            return function(first_input, second_input)
16        except TypeError:
17            return error_message
18    return decorator
19
20
21@numbers_only
22def subtract(first_input, second_input):
23    return first_input - second_input
24
25
26@numbers_only
27def multiply(first_input, second_input):
28    return first_input * second_input
29
30
31@numbers_only
32def divide(first_input, second_input):
33    try:
34        return first_input / second_input
35    except ZeroDivisionError:
36        return 'brmph?! I cannot divide by 0. Try again...'
37
38
39@numbers_only
40def add(first_input, second_input):
41    return first_input + second_input

booleans 3: tests

the tests in booleans/tests/test_booleans.py from booleans 3: values of True and False

 1import unittest
 2
 3
 4class TestBooleans(unittest.TestCase):
 5
 6    def test_what_is_false(self):
 7        self.assertIsInstance(False, (bool, int))
 8        self.assertNotIsInstance(False, float)
 9        for false_item in (
10            False,
11            None, bool(None),
12            0, 0.0, bool(0), bool(0.0),
13            str(), bool(str()),
14            tuple(), bool(tuple()),
15            list(), bool(list()),
16            set(), bool(set()),
17            dict(), bool(dict()),
18        ):
19            with self.subTest(item=false_item):
20                self.assertFalse(false_item)
21
22    def test_what_is_true(self):
23        self.assertIsInstance(True, (bool, int))
24        self.assertNotIsInstance(True, float)
25
26        for true_item in (
27            True,
28            -1, bool(-1), 1, bool(1),
29            -0.1, bool(-0.1), 0.1, bool(0.1),
30            "text", bool("text"),
31            ((1, 2, 3, 'n')), bool((1, 2, 3, 'n')),
32            [1, 2, 3, 'n'], bool([1, 2, 3, 'n']),
33            {1, 2, 3, 'n'}, bool({1, 2, 3, 'n'}),
34            {'key': 'value'}, bool({'key': 'value'}),
35        ):
36            with self.subTest(item=true_item):
37                self.assertTrue(true_item)
38
39    def test_the_value_of_false(self):
40        self.assertEqual(False+1, 1)
41        self.assertEqual(False-1, -1)
42        self.assertEqual(False*1, 0)
43        with self.assertRaises(ZeroDivisionError):
44            1 / False
45
46    def test_the_value_of_true(self):
47        self.assertEqual(True+1, 2)
48        self.assertEqual(True-1, 0)
49        self.assertEqual(True*1, 1)
50        self.assertEqual(True/1, 1)
51
52
53# NOTES
54# a dictionary with things is True
55# a set with things is True
56# a list with things is True
57# a tuple with things is True
58# a string with things is True
59# positive and negative numbers are True
60# True is True
61# True is not false
62# True is a boolean
63# True is an integer
64# True is not a float
65# True is 1
66# the empty dictionary is False
67# the empty set is False
68# the empty list is False
69# the empty tuple is False
70# the empty string is False
71# 0 is False
72# None is False
73# False is False
74# False is not true
75# False is a boolean
76# False is an integer
77# False is not a float
78# False is 0
79
80
81# Exceptions seen
82# AssertionError