data structures: list comprehensions: tests and solutions

list comprehensions tests

the code in 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 in 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?! cannot divide by 0. Try again...'
 56            )
 57
 58    def test_calculator_sends_message_when_input_is_not_a_number(self):
 59        error_message = 'brmph?! Numbers only. Try again...'
 60
 61        for data in (
 62            None,
 63            True, False,
 64            str(),
 65            tuple(),
 66            list(),
 67            set(),
 68            dict(),
 69        ):
 70            with self.subTest(i=data):
 71                self.assertEqual(
 72                    src.calculator.add(data, a_random_number()),
 73                    error_message
 74                )
 75                self.assertEqual(
 76                    src.calculator.divide(data, a_random_number()),
 77                    error_message
 78                )
 79                self.assertEqual(
 80                    src.calculator.multiply(data, a_random_number()),
 81                    error_message
 82                )
 83                self.assertEqual(
 84                    src.calculator.subtract(data, a_random_number()),
 85                    error_message
 86                )
 87
 88    def test_calculator_w_list_items(self):
 89        a_list = [self.random_first_number, self.random_second_number]
 90
 91        self.assertEqual(
 92            src.calculator.add(a_list[0], a_list[1]),
 93            self.random_first_number+self.random_second_number
 94        )
 95        self.assertEqual(
 96            src.calculator.divide(a_list[-2], a_list[-1]),
 97            self.random_first_number/self.random_second_number
 98        )
 99        self.assertEqual(
100            src.calculator.multiply(a_list[1], a_list[-1]),
101            self.random_second_number*self.random_second_number
102        )
103        self.assertEqual(
104            src.calculator.subtract(a_list[-2], a_list[0]),
105            self.random_first_number-self.random_first_number
106        )
107        self.assertEqual(
108            src.calculator.add(*a_list),
109            self.random_first_number+self.random_second_number
110        )
111        self.assertEqual(
112            src.calculator.divide(*a_list),
113            self.random_first_number/self.random_second_number
114        )
115        self.assertEqual(
116            src.calculator.multiply(*a_list),
117            self.random_first_number*self.random_second_number
118        )
119        self.assertEqual(
120            src.calculator.subtract(*a_list),
121            self.random_first_number-self.random_second_number
122        )
123
124    def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):
125        not_two_numbers = [0, 1, 2]
126
127        with self.assertRaises(TypeError):
128            src.calculator.add(*not_two_numbers)
129        with self.assertRaises(TypeError):
130            src.calculator.divide(*not_two_numbers)
131        with self.assertRaises(TypeError):
132            src.calculator.multiply(*not_two_numbers)
133        with self.assertRaises(TypeError):
134            src.calculator.subtract(*not_two_numbers)
135
136
137# Exceptions seen
138# AssertionError
139# NameError
140# AttributeError
141# TypeError
142# ZeroDivisionError
143# SyntaxError

how to make a calculator 6: solutions

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

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

booleans 2: tests

the tests in booleans/tests/test_booleans.py from booleans 2

 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,
12            0, 0.0,
13            str(),
14            tuple(),
15            list(),
16            set(),
17            dict(),
18        ):
19            with self.subTest(i=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        for true_item in (
26            True,
27            -1, 1,
28            -0.1, 0.1,
29            'text',
30            (1, 2, 3, 'n'),
31            [1, 2, 3, 'n'],
32            {1, 2, 3, 'n'},
33            {'key': 'value'},
34        ):
35            with self.subTest(i=true_item):
36                self.assertTrue(true_item)
37
38    def test_the_value_of_false(self):
39        self.assertEqual(False+1, 1)
40        self.assertEqual(False-1, -1)
41        self.assertEqual(False*1, 0)
42        with self.assertRaises(ZeroDivisionError):
43            1 / False
44
45    def test_the_value_of_true(self):
46        self.assertEqual(True+1, 2)
47        self.assertEqual(True-1, 0)
48        self.assertEqual(True*1, 1)
49        self.assertEqual(True/1, 1)
50
51
52# NOTES
53# a dictionary with things is true
54# a set with things is true
55# a list with things is true
56# a tuple with things is true
57# a string with things is true
58# positive and negative numbers are true
59# True is true
60# True is not false
61# True is a boolean
62# True is an integer
63# True is not a float
64# True is 1
65# the empty dictionary is false
66# the empty set is false
67# the empty list is false
68# the empty tuple is false
69# the empty string is false
70# 0 is false
71# None is false
72# False is false
73# False is not true
74# False is a boolean
75# False is an integer
76# False is not a float
77# False is 0
78
79
80# Exceptions seen
81# AssertionError