data structures: dictionaries: tests
dictionaries tests
the code from dictionaries/tests/test_dictionaries.py from dictionaries
1import unittest
2
3
4class TestDictionaries(unittest.TestCase):
5
6 def test_making_a_dictionary(self):
7 self.assertEqual(dict(), {})
8 self.assertEqual(dict(key='value'), {'key': 'value'})
9
10 def test_making_a_dictionary_w_none_as_a_key(self):
11 self.assertEqual({None: 'boom'}, {None: 'boom'})
12
13 def test_making_a_dictionary_w_a_boolean_as_a_key(self):
14 self.assertEqual(
15 {False: 'boom', True: 'bap'},
16 {False: 'boom', True: 'bap'}
17 )
18
19 def test_making_a_dictionary_w_a_number_as_a_key(self):
20 self.assertEqual(
21 {0: 'boom', 0.1: 'bap'},
22 {0: 'boom', 0.1: 'bap'}
23 )
24
25 def test_making_a_dictionary_w_a_tuple_as_a_key(self):
26 self.assertEqual(
27 {(0, 1): 'boom'},
28 {(0, 1): 'boom'}
29 )
30
31 def test_making_a_dictionary_w_a_list_as_a_key(self):
32 with self.assertRaises(TypeError):
33 {[3, 2, 1]: 'BOOM!!!'}
34
35 def test_making_a_dictionary_w_a_set_as_a_key(self):
36 with self.assertRaises(TypeError):
37 {{3, 2, 1}: 'BOOM!!!'}
38
39 def test_making_a_dictionary_w_a_dictionary_as_a_key(self):
40 a_dictionary = {'key': 'value'}
41 with self.assertRaises(TypeError):
42 {a_dictionary: 'BOOM!!!'}
43
44 def test_attributes_and_methods_of_dictionaries(self):
45 self.maxDiff = None
46 self.assertEqual(
47 dir(dict),
48 [
49 '__class__',
50 '__class_getitem__',
51 '__contains__',
52 '__delattr__',
53 '__delitem__',
54 '__dir__',
55 '__doc__',
56 '__eq__',
57 '__format__',
58 '__ge__',
59 '__getattribute__',
60 '__getitem__',
61 '__getstate__',
62 '__gt__',
63 '__hash__',
64 '__init__',
65 '__init_subclass__',
66 '__ior__',
67 '__iter__',
68 '__le__',
69 '__len__',
70 '__lt__',
71 '__ne__',
72 '__new__',
73 '__or__',
74 '__reduce__',
75 '__reduce_ex__',
76 '__repr__',
77 '__reversed__',
78 '__ror__',
79 '__setattr__',
80 '__setitem__',
81 '__sizeof__',
82 '__str__',
83 '__subclasshook__',
84 'clear',
85 'copy',
86 'fromkeys',
87 'get',
88 'items',
89 'keys',
90 'pop',
91 'popitem',
92 'setdefault',
93 'update',
94 'values'
95 ]
96 )
97
98 def test_clear_empties_a_dictionary(self):
99 a_dictionary = {'key': 'value'}
100 self.assertIsNone(a_dictionary.clear())
101 self.assertEqual(a_dictionary, {})
102
103 def test_copy_a_dictionary(self):
104 a_dictionary = {'key': 'value'}
105 self.assertEqual(
106 a_dictionary.copy(),
107 {'key': 'value'}
108 )
109
110 def test_fromkeys_makes_a_dictionary_from_an_iterable(self):
111 self.assertEqual(
112 dict.fromkeys((0, 1), 'default'),
113 {0: 'default', 1: 'default'}
114 )
115
116 def test_get_value_of_a_key_in_a_dictionary(self):
117 a_dictionary = {'key': 'value'}
118 self.assertEqual(
119 a_dictionary.get('not_in_dictionary', 'default'),
120 'default'
121 )
122 self.assertEqual(
123 a_dictionary.get('key', 'default'),
124 'value'
125 )
126
127 def test_items_returns_iterable_of_key_value_pairs_of_a_dictionary(self):
128 a_dictionary = {
129 'key1': 'value1',
130 'keyN': [0, 1, 2, 'n'],
131 }
132 self.assertEqual(
133 list(a_dictionary.items()),
134 [
135 ('key1', 'value1'),
136 ('keyN', [0, 1, 2, 'n']),
137 ]
138 )
139
140 def test_keys_of_a_dictionary(self):
141 a_dictionary = {
142 'key1': 'value1',
143 'keyN': [0, 1, 2, 'n'],
144 }
145 self.assertEqual(
146 list(a_dictionary.keys()),
147 ['key1', 'keyN']
148 )
149
150 def test_pop_removes_given_key_from_a_dictionary_and_returns_its_value(self):
151 a_dictionary = {'key': 'value'}
152
153 with self.assertRaises(KeyError):
154 a_dictionary.pop('not_in_dictionary')
155 self.assertEqual(
156 a_dictionary.pop('not_in_dictionary', 'default'),
157 'default'
158 )
159 self.assertEqual(
160 a_dictionary.pop('key', 'default'),
161 'value'
162 )
163 self.assertEqual(a_dictionary, {})
164
165 def test_popitem_removes_and_returns_last_key_value_pair_from_a_dictionary(self):
166 a_dictionary = {
167 'key1': 'value1',
168 'keyN': [0, 1, 2, 'n'],
169 }
170 self.assertEqual(
171 a_dictionary.popitem(),
172 ('keyN', [0, 1, 2, 'n'])
173 )
174 self.assertEqual(a_dictionary, {'key1': 'value1'})
175
176 def test_setdefault_adds_given_key_to_a_dictionary(self):
177 a_dictionary = {'key': 'value'}
178 self.assertEqual(
179 a_dictionary.setdefault('new_key', 'default'),
180 'default'
181 )
182 self.assertEqual(
183 a_dictionary.setdefault('key', 'default'),
184 'value'
185 )
186 self.assertEqual(
187 a_dictionary,
188 {
189 'key': 'value',
190 'new_key': 'default',
191 }
192 )
193
194 def test_update_a_dictionary(self):
195 a_dictionary = {'key': 'value'}
196 self.assertIsNone(a_dictionary.update(new_key=[0, 1, 2, 'n']))
197 self.assertIsNone(a_dictionary.update(key='updated value'))
198 self.assertIsNone(a_dictionary.update({
199 'another_key': {0, 1, 2, 'n'}
200 }))
201 self.assertEqual(
202 a_dictionary,
203 {
204 'key': 'updated value',
205 'new_key': [0, 1, 2, 'n'],
206 'another_key': {0, 1, 2, 'n'},
207 }
208 )
209
210 def test_values_of_a_dictionary(self):
211 a_dictionary = {
212 'key1': 'value1',
213 'keyN': [0, 1, 2, 'n'],
214 }
215 self.assertEqual(
216 list(a_dictionary.values()),
217 [
218 'value1',
219 [0, 1, 2, 'n'],
220 ]
221 )
222
223 def test_key_error(self):
224 a_dictionary = {'key': 'value'}
225 self.assertEqual(a_dictionary['key'], 'value')
226
227 with self.assertRaises(KeyError):
228 a_dictionary['not_in_dictionary']
229 self.assertEqual(
230 a_dictionary.get('not_in_dictionary', 'default'),
231 'default'
232 )
233
234 with self.assertRaises(KeyError):
235 a_dictionary.pop('not_in_dictionary')
236 self.assertEqual(
237 a_dictionary.pop('not_in_dictionary', 'default'),
238 'default'
239 )
240
241 with self.assertRaises(KeyError):
242 {}.popitem()
243
244
245# Exceptions seen
246# AssertionError
247# TypeError
248# NameError
249# KeyError
how to make a calculator 7: tests
the code from calculator/tests/test_calculator.py from how to make a calculator 7
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 @staticmethod
13 def get_division_result(x, y):
14 try:
15 return x / y
16 except ZeroDivisionError:
17 return 'brmph?! I cannot divide by 0. Try again...'
18
19 def setUp(self):
20 self.random_first_number = a_random_number()
21 self.random_second_number = a_random_number()
22
23 x = self.random_first_number
24 y = self.random_second_number
25
26 self.calculator_tests = {
27 'add': x+y,
28 'subtract': x-y,
29 'multiply': x*y,
30 'divide': self.get_division_result(x, y)
31 }
32
33 def test_calculator_w_list_items(self):
34 # two_numbers = [
35 # self.random_first_number,
36 # self.random_second_number
37 # ]
38 a_dictionary = {
39 'x': self.random_first_number,
40 'y': self.random_second_number
41 }
42 two_numbers = list(a_dictionary.values())
43
44 for operation in self.calculator_tests:
45 with self.subTest(operation=operation):
46 self.assertEqual(
47 src.calculator.__getattribute__(operation)(
48 *two_numbers
49 ),
50 self.calculator_tests[operation]
51 )
52
53 self.assertEqual(
54 src.calculator.add(
55 two_numbers[0],
56 two_numbers[1]
57 ),
58 self.random_first_number+self.random_second_number
59 )
60 self.assertEqual(
61 src.calculator.divide(
62 two_numbers[-2],
63 two_numbers[-1]
64 ),
65 self.random_first_number/self.random_second_number
66 )
67 self.assertEqual(
68 src.calculator.multiply(
69 two_numbers[1],
70 two_numbers[-1]
71 ),
72 self.random_second_number*self.random_second_number
73 )
74 self.assertEqual(
75 src.calculator.subtract(
76 two_numbers[-2],
77 two_numbers[0]
78 ),
79 self.random_first_number-self.random_first_number
80 )
81
82 def test_calculator_w_dictionary_items(self):
83 two_numbers = {
84 'first_input': self.random_first_number,
85 'second_input': self.random_second_number,
86 }
87
88 for operation in self.calculator_tests:
89 with self.subTest(operation=operation):
90 self.assertEqual(
91 src.calculator.__getattribute__(operation)(
92 **two_numbers
93 ),
94 self.calculator_tests[operation]
95 )
96
97 self.assertEqual(
98 src.calculator.add(
99 two_numbers['first_input'],
100 two_numbers['second_input']
101 ),
102 self.random_first_number+self.random_second_number
103 )
104 self.assertEqual(
105 src.calculator.divide(
106 two_numbers['first_input'],
107 two_numbers['second_input']
108 ),
109 self.random_first_number/self.random_second_number
110 )
111 self.assertEqual(
112 src.calculator.multiply(
113 two_numbers['second_input'],
114 two_numbers['second_input']
115 ),
116 self.random_second_number*self.random_second_number
117 )
118 self.assertEqual(
119 src.calculator.subtract(
120 two_numbers['first_input'],
121 two_numbers['first_input']
122 ),
123 self.random_first_number-self.random_first_number
124 )
125
126 def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):
127 for operation in self.calculator_tests:
128 with (
129 self.subTest(operation=operation),
130 self.assertRaises(TypeError),
131 ):
132 src.calculator.__getattribute__(operation)(
133 [0, 1, 2]
134 )
135
136 def test_calculator_sends_message_when_input_is_not_a_number(self):
137 for bad_input in (
138 None,
139 True, False,
140 str(), 'text',
141 tuple(), (0, 1, 2, 'n'),
142 list(), [0, 1, 2, 'n'],
143 set(), {0, 1, 2, 'n'},
144 dict(), {'key': 'value'},
145 ):
146 for operation in self.calculator_tests:
147 with self.subTest(
148 operation=operation,
149 bad_input=bad_input,
150 ):
151 self.assertEqual(
152 src.calculator.__getattribute__(operation)(
153 bad_input, a_random_number()
154 ),
155 'brmph?! Numbers only. Try again...'
156 )
157
158 def test_calculator_functions(self):
159 for operation in self.calculator_tests:
160 with self.subTest(operation=operation):
161 self.assertEqual(
162 src.calculator.__getattribute__(operation)(
163 self.random_first_number,
164 self.random_second_number
165 ),
166 self.calculator_tests[operation]
167 )
168
169
170# Exceptions seen
171# AssertionError
172# NameError
173# AttributeError
174# TypeError
175# KeyError