lists: tests and solutions

lists tests

the code in lists/tests/test_lists.py from lists

  1import unittest
  2
  3
  4class TestLists(unittest.TestCase):
  5
  6    def test_making_a_list(self):
  7        self.assertEqual(list(), [])
  8        self.assertEqual(list((0, 1, 2, 'n')), [0, 1, 2, 'n'])
  9
 10    def test_attributes_and_methods_of_lists(self):
 11        self.maxDiff = None
 12        self.assertEqual(
 13            dir(list),
 14            [
 15                '__add__',
 16                '__class__',
 17                '__class_getitem__',
 18                '__contains__',
 19                '__delattr__',
 20                '__delitem__',
 21                '__dir__',
 22                '__doc__',
 23                '__eq__',
 24                '__format__',
 25                '__ge__',
 26                '__getattribute__',
 27                '__getitem__',
 28                '__getstate__',
 29                '__gt__',
 30                '__hash__',
 31                '__iadd__',
 32                '__imul__',
 33                '__init__',
 34                '__init_subclass__',
 35                '__iter__',
 36                '__le__',
 37                '__len__',
 38                '__lt__',
 39                '__mul__',
 40                '__ne__',
 41                '__new__',
 42                '__reduce__',
 43                '__reduce_ex__',
 44                '__repr__',
 45                '__reversed__',
 46                '__rmul__',
 47                '__setattr__',
 48                '__setitem__',
 49                '__sizeof__',
 50                '__str__',
 51                '__subclasshook__',
 52                'append',
 53                'clear',
 54                'copy',
 55                'count',
 56                'extend',
 57                'index',
 58                'insert',
 59                'pop',
 60                'remove',
 61                'reverse',
 62                'sort',
 63            ]
 64        )
 65
 66    def test_append_adds_item_to_end_of_a_list(self):
 67        a_list = [0, 1, 2, 'n']
 68        self.assertIsNone(a_list.append('n+1'))
 69        self.assertEqual(a_list, [0, 1, 2, 'n', 'n+1'])
 70
 71    def test_clear_empties_a_list(self):
 72        a_list = [0, 1, 2, 'n']
 73        self.assertIsNone(a_list.clear())
 74        self.assertEqual(a_list, [])
 75
 76    def test_copy_a_list(self):
 77        a_list = [0, 1, 2, 'n']
 78        self.assertEqual(a_list.copy(), [0, 1, 2, 'n'])
 79
 80    def test_count_number_of_times_item_is_in_a_list(self):
 81        a_list = [0, 1, 2, 1, 'n', 1]
 82        self.assertEqual(a_list.count(0), 1)
 83        self.assertEqual(a_list.count(1), 3)
 84        self.assertEqual(a_list.count('not in list'), 0)
 85
 86    def test_extend_adds_items_from_an_iterable_to_end_of_a_list(self):
 87        a_list = [0, 1, 2, 'n']
 88        self.assertIsNone(a_list.extend((2, 1, 0)))
 89        self.assertEqual(a_list, [0, 1, 2, 'n', 2, 1, 0])
 90
 91    def test_index_returns_first_position_of_item_in_a_list(self):
 92        a_list = ['1st', '2nd', '3rd', '...last', '1st']
 93        self.assertEqual(a_list.index('1st', 0), 0)
 94        self.assertEqual(a_list.index('3rd', 0), 2)
 95        self.assertEqual(a_list.index('2nd', 0), 1)
 96        self.assertEqual(a_list.index('...last', 0), 3)
 97        self.assertEqual(a_list.index('1st', 1), 4)
 98
 99        with self.assertRaises(ValueError):
100            a_list.index('not in list')
101
102    def test_insert_item_at_position_in_a_list(self):
103        a_list = [0, 1, 2, 'n']
104        self.assertIsNone(a_list.insert(0, -1))
105        self.assertEqual(a_list, [-1, 0, 1, 2, 'n'])
106        self.assertIsNone(a_list.insert(3, 1.5))
107        self.assertEqual(a_list, [-1, 0, 1, 1.5, 2, 'n'])
108
109    def test_pop_removes_and_returns_last_item_from_a_list(self):
110        a_list = [0, 1, 2, 'n']
111        self.assertEqual(a_list.pop(), 'n')
112        self.assertEqual(a_list, [0, 1, 2])
113        self.assertEqual(a_list.pop(), 2)
114        self.assertEqual(a_list, [0, 1])
115
116    def test_remove_first_time_item_is_in_a_list(self):
117        a_list = [0, 1, 0, 2, 0, 'n']
118        self.assertIsNone(a_list.remove(0))
119        self.assertEqual(a_list, [1, 0, 2, 0, 'n'])
120
121        with self.assertRaises(ValueError):
122            a_list.remove('not in list')
123
124    def test_reverse_a_list(self):
125        a_list = [0, 1, 2, 'n']
126        self.assertIsNone(a_list.reverse())
127        self.assertEqual(a_list, ['n', 2, 1, 0])
128
129    def test_sort_a_list(self):
130        with self.assertRaises(TypeError):
131            [0, 1, 2, 'n'].sort()
132
133        a_list = [0, 1, -1, 2, -2, 3, -3]
134        self.assertIsNone(a_list.sort())
135        self.assertEqual(a_list, [-3, -2, -1, 0, 1, 2, 3])
136
137    def test_getting_items_of_a_list(self):
138        a_list = ['1st', '2nd', '3rd', '...last']
139        self.assertEqual(a_list[0], '1st')
140        self.assertEqual(a_list[a_list.index('1st')], '1st')
141        self.assertEqual(a_list[-4], '1st')
142        self.assertEqual(a_list[2], '3rd')
143        self.assertEqual(a_list[-2], '3rd')
144        self.assertEqual(a_list[1], '2nd')
145        self.assertEqual(a_list[-3], '2nd')
146        self.assertEqual(a_list[3], '...last')
147        self.assertEqual(a_list[-1], '...last')
148
149    def test_setting_items_in_a_list(self):
150        a_list = ['1st', '2nd', '3rd', '...last']
151        a_list[-1] = '4th'
152        self.assertEqual(a_list, ['1st', '2nd', '3rd', '4th'])
153
154    def test_looking_at_parts_of_a_list_aka_slicing(self):
155        a_list = ['a', 'b', 'c', 'd']
156        self.assertEqual(a_list[0:2], ['a', 'b'])
157        self.assertEqual(a_list[:2], ['a', 'b'])
158        self.assertEqual(a_list[1:4], ['b', 'c', 'd'])
159        self.assertEqual(a_list[1:], ['b', 'c', 'd'])
160        self.assertEqual(a_list[0:3], ['a', 'b', 'c'])
161        self.assertEqual(a_list[1:3], ['b', 'c'])
162        self.assertEqual(a_list[:], a_list.copy())
163
164    def test_index_error(self):
165        a_list = ['a', 'b', 'c', 'd']
166
167        with self.assertRaises(IndexError):
168            a_list[4]
169        with self.assertRaises(IndexError):
170            a_list[-5]
171        with self.assertRaises(IndexError):
172            [].pop()
173        with self.assertRaises(IndexError):
174            [][-1]
175
176
177# Exceptions seen
178# AssertionError
179# TypeError
180# ValueError
181# IndexError

lists with the Calculator tests

the code in calculator/tests/test_calculator.py from lists

  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    random_first_number = a_random_number()
 13    random_second_number = a_random_number()
 14
 15    def test_addition(self):
 16        self.assertEqual(
 17            src.calculator.add(
 18                self.random_first_number,
 19                self.random_second_number
 20            ),
 21            self.random_first_number+self.random_second_number
 22        )
 23
 24    def test_subtraction(self):
 25        self.assertEqual(
 26            src.calculator.subtract(
 27                self.random_first_number,
 28                self.random_second_number
 29            ),
 30            self.random_first_number-self.random_second_number
 31        )
 32
 33    def test_multiplication(self):
 34        self.assertEqual(
 35            src.calculator.multiply(
 36                self.random_first_number,
 37                self.random_second_number
 38            ),
 39            self.random_first_number*self.random_second_number
 40        )
 41
 42    def test_division(self):
 43        try:
 44            self.assertEqual(
 45                src.calculator.divide(
 46                    self.random_first_number,
 47                    self.random_second_number
 48                ),
 49                self.random_first_number/self.random_second_number
 50            )
 51        except ZeroDivisionError:
 52            self.assertEqual(
 53                src.calculator.divide(self.random_first_number, 0),
 54                'brmph?! cannot divide by 0. Try again...'
 55            )
 56
 57    def test_calculator_sends_message_when_input_is_not_a_number(self):
 58        error_message = 'Excuse me?! Numbers only! try again...'
 59
 60        self.assertEqual(
 61            src.calculator.add(None, None),
 62            error_message
 63        )
 64        self.assertEqual(
 65            src.calculator.divide(None, None),
 66            error_message
 67        )
 68        self.assertEqual(
 69            src.calculator.multiply(None, None),
 70            error_message
 71        )
 72        self.assertEqual(
 73            src.calculator.subtract(None, None),
 74            error_message
 75        )
 76        self.assertEqual(
 77            src.calculator.add('1', '1'),
 78            error_message
 79        )
 80        self.assertEqual(
 81            src.calculator.divide('1', '1'),
 82            error_message
 83        )
 84        self.assertEqual(
 85            src.calculator.multiply('1', '1'),
 86            error_message
 87        )
 88        self.assertEqual(
 89            src.calculator.subtract('1', '1'),
 90            error_message
 91        )
 92
 93        a_list = [0, 1, 2, 3]
 94
 95        self.assertEqual(
 96            src.calculator.add(a_list, 0),
 97            error_message
 98        )
 99        self.assertEqual(
100            src.calculator.divide(a_list, 1),
101            error_message
102        )
103        self.assertEqual(
104            src.calculator.multiply(a_list, 2),
105            error_message
106        )
107        self.assertEqual(
108            src.calculator.subtract(a_list, 3),
109            error_message
110        )
111
112    def test_calculator_w_list_items(self):
113        a_list = [self.random_first_number, self.random_second_number]
114
115        self.assertEqual(
116            src.calculator.add(a_list[0], a_list[1]),
117            self.random_first_number+self.random_second_number
118        )
119        self.assertEqual(
120            src.calculator.divide(a_list[-2], a_list[-1]),
121            self.random_first_number/self.random_second_number
122        )
123        self.assertEqual(
124            src.calculator.multiply(a_list[1], a_list[-1]),
125            self.random_second_number*self.random_second_number
126        )
127        self.assertEqual(
128            src.calculator.subtract(a_list[-2], a_list[0]),
129            self.random_first_number-self.random_first_number
130        )
131        self.assertEqual(
132            src.calculator.add(*a_list),
133            self.random_first_number+self.random_second_number
134        )
135        self.assertEqual(
136            src.calculator.divide(*a_list),
137            self.random_first_number/self.random_second_number
138        )
139        self.assertEqual(
140            src.calculator.multiply(*a_list),
141            self.random_first_number*self.random_second_number
142        )
143        self.assertEqual(
144            src.calculator.subtract(*a_list),
145            self.random_first_number-self.random_second_number
146        )
147
148    def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):
149        not_two_numbers = [0, 1, 2]
150
151        with self.assertRaises(TypeError):
152            src.calculator.add(*not_two_numbers)
153        with self.assertRaises(TypeError):
154            src.calculator.divide(*not_two_numbers)
155        with self.assertRaises(TypeError):
156            src.calculator.multiply(*not_two_numbers)
157        with self.assertRaises(TypeError):
158            src.calculator.subtract(*not_two_numbers)
159
160
161# Exceptions seen
162# AssertionError
163# NameError
164# AttributeError
165# TypeError
166# ZeroDivisionError
167# SyntaxError

lists with the Calculator solutions

the solutions in calculator/src/calculator.py from lists

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