another way to write tests: tests

The code in unittest/tests/test_unittest.py from another way to write tests

  1import unittest
  2
  3
  4class TestUnittest(unittest.TestCase):
  5
  6    def test_dir_unittest(self):
  7        reality = dir(unittest)
  8        my_expectation = [
  9            'BaseTestSuite', 'FunctionTestCase',
 10            'IsolatedAsyncioTestCase', 'SkipTest',
 11            'TestCase', 'TestLoader', 'TestProgram',
 12            'TestResult', 'TestSuite', 'TextTestResult',
 13            'TextTestRunner', '__all__', '__builtins__',
 14            '__cached__', '__dir__', '__doc__',
 15            '__file__', '__getattr__', '__loader__',
 16            '__name__', '__package__', '__path__',
 17            '__spec__', '__unittest', 'addModuleCleanup',
 18            'case', 'defaultTestLoader', 'doModuleCleanups',
 19            'enterModuleContext', 'expectedFailure',
 20            'installHandler', 'loader', 'main',
 21            'registerResult', 'removeHandler', 'removeResult',
 22            'result', 'runner', 'signals', 'skip', 'skipIf',
 23            'skipUnless', 'suite', 'util'
 24        ]
 25        assert reality == my_expectation
 26        self.assertEqual(reality, my_expectation)
 27
 28    def test_dir_unittest_testcase(self):
 29        reality = dir(unittest.TestCase)
 30        my_expectation = [
 31            '__call__', '__class__', '__delattr__',
 32            '__dict__', '__dir__', '__doc__', '__eq__',
 33            '__firstlineno__', '__format__', '__ge__',
 34            '__getattribute__', '__getstate__', '__gt__',
 35            '__hash__', '__init__', '__init_subclass__',
 36            '__le__', '__lt__', '__module__', '__ne__',
 37            '__new__', '__reduce__', '__reduce_ex__',
 38            '__repr__', '__setattr__', '__sizeof__',
 39            '__static_attributes__', '__str__',
 40            '__subclasshook__', '__weakref__',
 41            '_addDuration', '_addExpectedFailure',
 42            '_addUnexpectedSuccess', '_assertNotWarns',
 43            '_baseAssertEqual', '_callCleanup',
 44            '_callSetUp', '_callTearDown', '_callTestMethod',
 45            '_diffThreshold', '_formatMessage',
 46            '_getAssertEqualityFunc', '_tail_type_check',
 47            '_truncateMessage', 'addClassCleanup',
 48            'addCleanup', 'addTypeEqualityFunc',
 49            'assertAlmostEqual', 'assertCountEqual',
 50            'assertDictEqual', 'assertEndsWith',
 51            'assertEqual', 'assertFalse', 'assertGreater',
 52            'assertGreaterEqual', 'assertHasAttr',
 53            'assertIn', 'assertIs', 'assertIsInstance',
 54            'assertIsNone', 'assertIsNot',
 55            'assertIsNotNone', 'assertIsSubclass',
 56            'assertLess', 'assertLessEqual',
 57            'assertListEqual', 'assertLogs',
 58            'assertMultiLineEqual', 'assertNoLogs',
 59            'assertNotAlmostEqual', 'assertNotEndsWith',
 60            'assertNotEqual', 'assertNotHasAttr',
 61            'assertNotIn', 'assertNotIsInstance',
 62            'assertNotIsSubclass', 'assertNotRegex',
 63            'assertNotStartsWith', 'assertRaises',
 64            'assertRaisesRegex', 'assertRegex',
 65            'assertSequenceEqual', 'assertSetEqual',
 66            'assertStartsWith', 'assertTrue',
 67            'assertTupleEqual', 'assertWarns',
 68            'assertWarnsRegex', 'countTestCases',
 69            'debug', 'defaultTestResult',
 70            'doClassCleanups', 'doCleanups',
 71            'enterClassContext', 'enterContext', 'fail',
 72            'failureException', 'id', 'longMessage',
 73            'maxDiff', 'run', 'setUp', 'setUpClass',
 74            'shortDescription', 'skipTest', 'subTest',
 75            'tearDown', 'tearDownClass'
 76        ]
 77        assert reality == my_expectation
 78        self.assertEqual(reality, my_expectation)
 79
 80    def test_assert_is_not(self):
 81        assert None is not False
 82        self.assertIsNot(None, False)
 83
 84    def test_assert_is(self):
 85        assert False is False
 86        self.assertIs(False, False)
 87
 88    def test_assert_not_equal(self):
 89        assert True != 0
 90        self.assertNotEqual(True, 0)
 91
 92    def test_assert_equal(self):
 93        assert 0.0 == 0.0
 94        self.assertEqual(0.0, 0.0)
 95
 96    def test_assert_not_is_instance(self):
 97        assert not isinstance(
 98            unittest.TestCase, unittest.TestCase
 99        )
100        self.assertNotIsInstance(
101            unittest.TestCase, unittest.TestCase
102        )
103
104    def test_assert_is_instance(self):
105        a_class = unittest.TestCase
106        an_instance = a_class()
107
108        assert isinstance(an_instance, a_class)
109        self.assertIsInstance(
110            an_instance, a_class
111        )
112        self.assertIsInstance(
113            self, unittest.TestCase
114        )
115
116    def test_assert_not_is_subclass(self):
117        assert not issubclass(
118            unittest.TestCase, list
119        )
120        self.assertNotIsSubclass(
121            unittest.TestCase, dict
122        )
123
124    def test_assert_is_subclass(self):
125        assert issubclass(unittest.TestCase, object)
126        self.assertIsSubclass(
127            unittest.TestCase, object
128        )
129        self.assertIsSubclass(
130            TestUnittest, unittest.TestCase
131        )
132
133
134# Exceptions seen
135# AssertionError
136# NameError
137# TypeError
138# AttributeError

test AssertionError with unittest: tests

The code in assertion_error/tests/test_assertion_error.py from test AssertionError with unittest

  1import unittest
  2
  3
  4class TestAssertionError(unittest.TestCase):
  5
  6    an_integer = 0
  7    a_float = 0.0
  8    a_string = ''
  9    a_tuple = ()
 10    a_list = []
 11    a_set = set()
 12    a_dictionary = {}
 13
 14    def test_assert_keyword(self):
 15        reality = 1 + 1
 16        my_expectation = 2
 17        assert reality == my_expectation
 18        self.assertEqual(reality, my_expectation)
 19
 20        reality = '1' + '1'
 21        my_expectation = '11'
 22        assert reality == my_expectation
 23        self.assertEqual(reality, my_expectation)
 24
 25        reality = 'I am' + ' alive'
 26        my_expectation = 'I am alive'
 27        assert reality == my_expectation
 28        self.assertEqual(reality, my_expectation)
 29
 30    def test_assertion_error_w_none(self):
 31        assert None is None
 32        self.assertIs(None, None)
 33
 34        assert False is not None
 35        self.assertIsNot(False, None)
 36
 37        assert True is not None
 38        self.assertIsNot(True, None)
 39
 40        assert self.an_integer is not None
 41        self.assertIsNot(self.an_integer, None)
 42
 43        assert self.a_float is not None
 44        self.assertIsNot(self.a_float, None)
 45
 46        assert self.a_string is not None
 47        self.assertIsNot(self.a_string, None)
 48
 49        assert self.a_tuple is not None
 50        self.assertIsNot(self.a_tuple, None)
 51
 52        assert self.a_list is not None
 53        self.assertIsNot(self.a_list, None)
 54
 55        assert self.a_set is not None
 56        self.assertIsNot(self.a_set, None)
 57
 58        assert self.a_dictionary is not None
 59        self.assertIsNot(self.a_dictionary, None)
 60
 61    def test_assertion_error_w_false(self):
 62        assert None is not False
 63        self.assertIsNot(None, False)
 64
 65        assert False is False
 66        self.assertIs(False, False)
 67
 68        assert True is not False
 69        self.assertIsNot(True, False)
 70
 71        assert self.an_integer is not False
 72        self.assertIsNot(self.an_integer, False)
 73
 74        assert self.a_float is not False
 75        self.assertIsNot(self.a_float, False)
 76
 77        assert self.a_string is not False
 78        self.assertIsNot(self.a_string, False)
 79
 80        assert self.a_tuple is not False
 81        self.assertIsNot(self.a_tuple, False)
 82
 83        assert self.a_list is not False
 84        self.assertIsNot(self.a_list, False)
 85
 86        assert self.a_set is not False
 87        self.assertIsNot(self.a_set, False)
 88
 89        assert self.a_dictionary is not False
 90        self.assertIsNot(self.a_dictionary, False)
 91
 92    def test_assertion_error_w_true(self):
 93        assert None is not True
 94        self.assertIsNot(None, True)
 95
 96        assert False is not True
 97        self.assertIsNot(False, True)
 98
 99        assert True is True
100        self.assertIs(True, True)
101
102        assert self.an_integer is not True
103        self.assertIsNot(self.an_integer, True)
104
105        assert self.a_float is not True
106        self.assertIsNot(self.a_float, True)
107
108        assert self.a_string is not True
109        self.assertIsNot(self.a_string, True)
110
111        assert self.a_tuple is not True
112        self.assertIsNot(self.a_tuple, True)
113
114        assert self.a_list is not True
115        self.assertIsNot(self.a_list, True)
116
117        assert self.a_set is not True
118        self.assertIsNot(self.a_set, True)
119
120        assert self.a_dictionary is not True
121        self.assertIsNot(self.a_dictionary, True)
122
123    def test_assertion_error_w_equality(self):
124        assert None == None
125        self.assertEqual(None, None)
126
127        assert False != None
128        self.assertNotEqual(False, None)
129
130        assert False != True
131        self.assertNotEqual(False, True)
132
133        assert False == False
134        self.assertEqual(False, False)
135
136        assert True != None
137        self.assertNotEqual(True, None)
138
139        assert True == True
140        self.assertEqual(True, True)
141
142    def test_assertion_error_w_is_vs_equal(self):
143        assert 0 is not 0.0
144        self.assertIsNot(0, 0.0)
145
146        assert 0 == 0.0
147        self.assertEqual(0, 0.0)
148
149    def will_not_run():
150        assert False == True
151        self.assertEqual(False, True)
152
153    def test_failure(self):
154        assert False == False
155        self.assertEqual(False, False)
156
157
158# NOTES
159# a dictionary is not True
160# a dictionary is not False
161# a dictionary is not None
162# a set is not True
163# a set is not False
164# a set is not None
165# a list is not True
166# a list is not False
167# a list is not None
168# a tuple is not True
169# a tuple is not False
170# a tuple is not None
171# a string is not True
172# a string is not False
173# a string is not None
174# a float is not True
175# a float is not False
176# a float is not None
177# an integer is not True
178# an integer is not False
179# an integer is not None
180# True is True and equal to True
181# True is not False and NOT equal to False
182# True is not None and NOT equal to None
183# False is not True and NOT equal to True
184# False is False and equal to False
185# False is not None and NOT equal to None
186# None is not True and NOT equal to True
187# None is not False and NOT equal to False
188# None is None and equal to None
189
190
191# Exceptions seen
192# AssertionError
193# AttributeError
194# NameError
195# TypeError

test objects with unittest: tests

The code in classes/tests/test_classes.py from test objects with unittest

  1import unittest
  2
  3
  4class WPass: pass
  5
  6
  7class WParentheses(): pass
  8
  9
 10class WObject(object): pass
 11
 12
 13class TestClasses(unittest.TestCase):
 14
 15    def test_making_a_class_w_pass(self):
 16        assert isinstance(WPass(), object)
 17        self.assertIsInstance(WPass(), object)
 18
 19        assert issubclass(WPass, object)
 20        self.assertIsSubclass(WPass, object)
 21
 22    def test_making_a_class_w_parentheses(self):
 23        assert isinstance(WParentheses(), object)
 24        self.assertIsInstance(WParentheses(), object)
 25
 26        assert issubclass(WParentheses, object)
 27        self.assertIsSubclass(WParentheses, object)
 28
 29    def test_making_a_class_w_object(self):
 30        assert isinstance(WObject(), object)
 31        self.assertIsInstance(WObject(), object)
 32
 33        assert issubclass(WObject, object)
 34        self.assertIsSubclass(WObject, object)
 35
 36    def test_is_none_an_object(self):
 37        assert isinstance(None, object)
 38        self.assertIsInstance(None, object)
 39
 40        # fails because None is not a class
 41        # assert issubclass(None, object)
 42        # self.assertIsSubclass(None, object)
 43
 44    def test_is_a_boolean_an_object(self):
 45        assert isinstance(bool, object)
 46        self.assertIsInstance(bool, object)
 47
 48        assert issubclass(bool, object)
 49        self.assertIsSubclass(bool, object)
 50
 51    def test_is_an_integer_an_object(self):
 52        assert isinstance(int, object)
 53        self.assertIsInstance(int, object)
 54
 55        assert issubclass(int, object)
 56        self.assertIsSubclass(int, object)
 57
 58    def test_is_a_float_an_object(self):
 59        assert isinstance(float, object)
 60        self.assertIsInstance(float, object)
 61
 62        assert issubclass(float, object)
 63        self.assertIsSubclass(float, object)
 64
 65    def test_is_a_string_an_object(self):
 66        assert isinstance(str, object)
 67        self.assertIsInstance(str, object)
 68
 69        assert issubclass(str, object)
 70        self.assertIsSubclass(str, object)
 71
 72    def test_is_a_tuple_an_object(self):
 73        assert isinstance(tuple, object)
 74        self.assertIsInstance(tuple, object)
 75
 76        assert issubclass(tuple, object)
 77        self.assertIsSubclass(tuple, object)
 78
 79    def test_is_a_list_an_object(self):
 80        assert isinstance(list, object)
 81        self.assertIsInstance(list, object)
 82
 83        assert issubclass(list, object)
 84        self.assertIsSubclass(list, object)
 85
 86    def test_is_a_set_an_object(self):
 87        assert isinstance(set, object)
 88        self.assertIsInstance(set, object)
 89
 90        assert issubclass(set, object)
 91        self.assertIsSubclass(set, object)
 92
 93    def test_is_a_dictionary_an_object(self):
 94        assert isinstance(dict, object)
 95        self.assertIsInstance(dict, object)
 96
 97        assert issubclass(dict, object)
 98        self.assertIsSubclass(dict, object)
 99
100    def test_dir_object(self):
101        reality = dir(object)
102        my_expectation = [
103            '__class__', '__delattr__', '__dir__',
104            '__doc__', '__eq__', '__format__', '__ge__',
105            '__getattribute__', '__getstate__', '__gt__',
106            '__hash__', '__init__', '__init_subclass__',
107            '__le__', '__lt__', '__ne__', '__new__',
108            '__reduce__', '__reduce_ex__', '__repr__',
109            '__setattr__', '__sizeof__', '__str__',
110            '__subclasshook__'
111        ]
112        assert reality == my_expectation
113        self.assertEqual(reality, my_expectation)
114
115
116# Exceptions seen
117# AssertionError
118# NameError
119# TypeError
120# AttributeError

test functions with unittest: tests

The code in functions/tests/test_functions.py from test functions with unittest

  1import src.functions
  2import unittest
  3
  4
  5class TestFunctions(unittest.TestCase):
  6
  7    first = 'first'
  8    last = 'last'
  9    a_tuple = (0, 1, 2, 'n')
 10    a_list = [0, 1, 2, 'n']
 11    a_set = {0, 1, 2, 'n'}
 12    a_dictionary = {'key': 'value'}
 13
 14    def test_making_a_function_w_pass(self):
 15        result = src.functions.w_pass()
 16
 17        assert result is None
 18        self.assertIs(result, None)
 19
 20    def test_making_a_function_w_return(self):
 21        result = src.functions.w_return()
 22
 23        assert result is None
 24        self.assertIs(result, None)
 25
 26    def test_making_a_function_w_return_none(self):
 27        result = src.functions.w_return_none()
 28
 29        assert result is None
 30        self.assertIs(result, None)
 31
 32    def test_what_happens_after_functions_return(self):
 33        result = src.functions.return_leaves_the_function()
 34
 35        assert result is None
 36        self.assertIs(result, None)
 37
 38    def test_constant_function(self):
 39        result = src.functions.constant()
 40        expectation = 'the same thing'
 41
 42        assert result == expectation
 43        self.assertEqual(result, expectation)
 44
 45    def test_identity_function(self):
 46        result = src.functions.identity(None)
 47
 48        assert result == None
 49        self.assertEqual(result, None)
 50
 51        result = src.functions.identity(object)
 52
 53        assert result == object
 54        self.assertEqual(result, object)
 55
 56    def test_why_use_a_function(self):
 57        def add_x(number):
 58            return 3 + number
 59
 60        result = add_x(0)
 61        expectation = 3
 62        assert result == expectation
 63        self.assertEqual(result, expectation)
 64
 65        result = add_x(1)
 66        expectation = 4
 67        assert result == expectation
 68        self.assertEqual(result, expectation)
 69
 70        result = add_x(2)
 71        expectation = 5
 72        assert result == expectation
 73        self.assertEqual(result, expectation)
 74
 75        result = add_x(3)
 76        expectation = 6
 77        assert result == expectation
 78        self.assertEqual(result, expectation)
 79
 80        result = add_x(4)
 81        expectation = 7
 82        assert result == expectation
 83        self.assertEqual(result, expectation)
 84
 85        result = add_x(5)
 86        expectation = 8
 87        assert result == expectation
 88        self.assertEqual(result, expectation)
 89
 90        result = add_x(6)
 91        expectation = 9
 92        assert result == expectation
 93        self.assertEqual(result, expectation)
 94
 95        result = add_x(7)
 96        expectation = 10
 97        assert result == expectation
 98        self.assertEqual(result, expectation)
 99
100        result = add_x(8)
101        expectation = 11
102        assert result == expectation
103        self.assertEqual(result, expectation)
104
105        result = add_x(9)
106        expectation = 12
107        assert result == expectation
108        self.assertEqual(result, expectation)
109
110    def test_positional_arguments(self):
111        positional_arguments = (
112            src.functions.positional_arguments
113        )
114
115        reality = positional_arguments(
116            self.first, self.last
117        )
118        my_expectation = (self.first, self.last)
119        assert reality == my_expectation
120        self.assertEqual(reality, my_expectation)
121
122        reality = positional_arguments(
123            self.last, self.first
124        )
125        my_expectation = (self.last, self.first)
126        assert reality == my_expectation
127        self.assertEqual(reality, my_expectation)
128
129        reality = positional_arguments(0, 1)
130        my_expectation = (0, 1)
131        assert reality == my_expectation
132        self.assertEqual(reality, my_expectation)
133
134        reality = positional_arguments(
135            self.a_tuple, self.a_list
136        )
137
138        my_expectation = (self.a_tuple, self.a_list)
139        assert reality == my_expectation
140        self.assertEqual(reality, my_expectation)
141
142        keyword_arguments = (
143            src.functions.keyword_arguments
144        )
145
146        reality = keyword_arguments(
147            self.a_set, self.a_dictionary,
148        )
149        my_expectation = (
150            self.a_set, self.a_dictionary
151        )
152        assert reality == my_expectation
153        self.assertEqual(reality, my_expectation)
154
155    def test_keyword_arguments(self):
156        keyword_arguments = (
157            src.functions.keyword_arguments
158        )
159
160        reality = keyword_arguments(
161            first_input=self.first,
162            last_input=self.last,
163        )
164        my_expectation = (self.first, self.last)
165        assert reality == my_expectation
166        self.assertEqual(reality, my_expectation)
167
168        reality = keyword_arguments(
169            last_input=self.last,
170            first_input=self.first,
171        )
172        my_expectation = (self.first, self.last)
173        assert reality == my_expectation
174        self.assertEqual(reality, my_expectation)
175
176        reality = keyword_arguments(
177            last_input=0, first_input=1,
178        )
179        my_expectation = (1, 0)
180        assert reality == my_expectation
181        self.assertEqual(reality, my_expectation)
182
183        reality = keyword_arguments(
184            first_input=self.a_tuple,
185            last_input=self.a_list,
186        )
187        my_expectation = (self.a_tuple, self.a_list)
188        assert reality == my_expectation
189        self.assertEqual(reality, my_expectation)
190
191        positional_arguments = (
192            src.functions.positional_arguments
193        )
194
195        reality = positional_arguments(
196            last_input=self.a_dictionary,
197            first_input=self.a_set,
198        )
199        my_expectation = (
200            self.a_set, self.a_dictionary
201        )
202        assert reality == my_expectation
203        self.assertEqual(reality, my_expectation)
204
205    def test_args_and_kwargs(self):
206        reality = src.functions.args_and_kwargs(
207            self.first, last_input=self.last,
208        )
209        my_expectation = (self.first, self.last)
210        assert reality == my_expectation
211        self.assertEqual(reality, my_expectation)
212
213    def test_optional_arguments(self):
214        optional_arguments = (
215            src.functions.optional_arguments
216        )
217
218        first_name, last_name = 'jane', 'doe'
219
220        reality = optional_arguments(first_name)
221        my_expectation = (first_name, last_name)
222        assert reality == my_expectation
223        self.assertEqual(reality, my_expectation)
224
225        first_name, blow = 'joe', 'blow'
226
227        reality = optional_arguments(
228            first_name, blow
229        )
230        my_expectation = (first_name, blow)
231        assert reality == my_expectation
232        self.assertEqual(reality, my_expectation)
233
234        first_name = 'john'
235
236        reality = optional_arguments(
237            first_input=first_name
238        )
239        my_expectation = (first_name, last_name)
240        assert reality == my_expectation
241        self.assertEqual(reality, my_expectation)
242
243        last_name = 'smith'
244
245        reality = optional_arguments(
246            last_input=last_name,
247            first_input=first_name,
248        )
249        my_expectation = (first_name, last_name)
250        assert reality == my_expectation
251        self.assertEqual(reality, my_expectation)
252
253    def test_unknown_number_of_arguments(self):
254        unknown_number_of_arguments = (
255            src.functions.unknown_number_of_arguments
256        )
257
258        a_tuple = (0, 1)
259        a_dictionary = {'a': 2, 'b': 3}
260
261        reality = unknown_number_of_arguments(
262            *a_tuple, **a_dictionary
263        )
264        my_expectation = (a_tuple, a_dictionary)
265        assert reality == my_expectation
266        self.assertEqual(reality, my_expectation)
267
268        a_tuple = (0, 1)
269        a_dictionary = {'a': 2, 'b': 3, 'c': 4}
270
271        reality = unknown_number_of_arguments(
272            *a_tuple, **a_dictionary
273        )
274        my_expectation = (a_tuple, a_dictionary)
275        assert reality == my_expectation
276        self.assertEqual(reality, my_expectation)
277
278        a_tuple = (0, 1, 2)
279        a_dictionary = {'a': 3, 'b': 4, 'c': 5}
280
281        reality = unknown_number_of_arguments(
282            *a_tuple, **a_dictionary
283        )
284        my_expectation = (a_tuple, a_dictionary)
285        assert reality == my_expectation
286        self.assertEqual(reality, my_expectation)
287
288        a_tuple = (0, 1, 2, 'n')
289
290        reality = unknown_number_of_arguments(*a_tuple)
291        my_expectation = (a_tuple, {})
292        assert reality == my_expectation
293        self.assertEqual(reality, my_expectation)
294
295        a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
296
297        reality = unknown_number_of_arguments(
298            **a_dictionary
299        )
300        my_expectation = ((), a_dictionary)
301        assert reality == my_expectation
302        self.assertEqual(reality, my_expectation)
303
304        reality = unknown_number_of_arguments()
305        my_expectation = ((), {})
306        assert reality == my_expectation
307        self.assertEqual(reality, my_expectation)
308
309
310# Exceptions seen
311# AssertionError
312# NameError
313# TypeError
314# SyntaxError
315# ModuleNotFoundError
316# AttributeError

test person with unittest: tests

The code in person/tests/test_person.py from test person with unittest

  1import src.person
  2import unittest
  3
  4
  5class TestPerson(unittest.TestCase):
  6
  7    def test_joe(self):
  8        first_name = 'joe'
  9        last_name = 'blow'
 10        sex = 'M'
 11        year_of_birth = 1996
 12
 13        reality = src.person.factory(
 14            first_name=first_name,
 15            last_name=last_name,
 16            sex=sex,
 17            year_of_birth=year_of_birth,
 18        )
 19        my_expectation = (
 20            f'{first_name}, {last_name},'
 21            f' {sex}, {year_of_birth}'
 22        )
 23        assert reality == my_expectation
 24        self.assertEqual(reality, my_expectation)
 25
 26        reality = src.person.say_hello(
 27            first_name=first_name,
 28            last_name=last_name,
 29            year_of_birth=year_of_birth,
 30        )
 31        my_expectation = (
 32            f'Hello, my name is {first_name}'
 33            f' {last_name} and I am'
 34            f' {2026-year_of_birth}.'
 35        )
 36        assert reality == my_expectation
 37        self.assertEqual(reality, my_expectation)
 38
 39        joe = src.person.Person(
 40            first_name=first_name,
 41            last_name=last_name,
 42            sex=sex,
 43            year_of_birth=year_of_birth,
 44        )
 45
 46        reality = joe.say_hello()
 47        assert reality == my_expectation
 48        self.assertEqual(reality, my_expectation)
 49
 50    def test_jane(self):
 51        first_name = 'jane'
 52        last_name = 'doe'
 53        sex = 'F'
 54        year_of_birth = 1991
 55
 56        reality = src.person.factory(
 57            first_name=first_name,
 58            last_name=last_name,
 59            sex=sex,
 60            year_of_birth=year_of_birth,
 61        )
 62        my_expectation = (
 63            f'{first_name}, {last_name},'
 64            f' {sex}, {year_of_birth}'
 65        )
 66        assert reality == my_expectation
 67        self.assertEqual(reality, my_expectation)
 68
 69        reality = src.person.say_hello(
 70            first_name=first_name,
 71            last_name=last_name,
 72            year_of_birth=year_of_birth,
 73        )
 74        my_expectation = (
 75            f'Hello, my name is {first_name}'
 76            f' {last_name} and I am'
 77            f' {2026-year_of_birth}.'
 78        )
 79        assert reality == my_expectation
 80        self.assertEqual(reality, my_expectation)
 81
 82        jane = src.person.Person(
 83            first_name=first_name,
 84            last_name=last_name,
 85            sex=sex,
 86            year_of_birth=year_of_birth,
 87        )
 88
 89        reality = jane.say_hello()
 90        assert reality == my_expectation
 91        self.assertEqual(reality, my_expectation)
 92
 93    def test_john(self):
 94        first_name = 'john'
 95        last_name = 'smith'
 96        sex = 'M'
 97        year_of_birth = 1580
 98
 99        reality = src.person.factory(
100            first_name=first_name,
101            last_name=last_name,
102            sex=sex,
103            year_of_birth=year_of_birth,
104        )
105        my_expectation = (
106            f'{first_name}, {last_name},'
107            f' {sex}, {year_of_birth}'
108        )
109        assert reality == my_expectation
110        self.assertEqual(reality, my_expectation)
111
112        reality = src.person.say_hello(
113            first_name=first_name,
114            last_name=last_name,
115            year_of_birth=year_of_birth,
116        )
117        my_expectation = (
118            f'Hello, my name is {first_name}'
119            f' {last_name} and I am'
120            f' {2026-year_of_birth}.'
121        )
122        assert reality == my_expectation
123        self.assertEqual(reality, my_expectation)
124
125        john = src.person.Person(
126            first_name=first_name,
127            last_name=last_name,
128            sex=sex,
129            year_of_birth=year_of_birth,
130        )
131
132        reality = john.say_hello()
133        assert reality == my_expectation
134        self.assertEqual(reality, my_expectation)
135
136    def test_mary(self):
137        first_name = 'mary'
138        last_name = 'public'
139        sex = 'F'
140        year_of_birth = 2000
141
142        reality = src.person.factory(
143            first_name=first_name,
144            last_name=last_name,
145            sex=sex,
146            year_of_birth=year_of_birth,
147        )
148        my_expectation = (
149            f'{first_name}, {last_name},'
150            f' {sex}, {year_of_birth}'
151        )
152        assert reality == my_expectation
153        self.assertEqual(reality, my_expectation)
154
155        reality = src.person.say_hello(
156            first_name=first_name,
157            last_name=last_name,
158            year_of_birth=year_of_birth,
159        )
160        my_expectation = (
161            f'Hello, my name is {first_name}'
162            f' {last_name} and I am'
163            f' {2026-year_of_birth}.'
164        )
165        assert reality == my_expectation
166        self.assertEqual(reality, my_expectation)
167
168        mary = src.person.Person(
169            first_name=first_name,
170            last_name=last_name,
171            sex=sex,
172            year_of_birth=year_of_birth,
173        )
174
175        reality = mary.say_hello()
176        assert reality == my_expectation
177        self.assertEqual(reality, my_expectation)
178
179    def test_dir_person_class(self):
180        reality = dir(src.person.Person)
181        my_expectation = [
182            '__class__',
183            '__delattr__',
184            '__dict__',
185            '__dir__',
186            '__doc__',
187            '__eq__',
188            '__firstlineno__',
189            '__format__',
190            '__ge__',
191            '__getattribute__',
192            '__getstate__',
193            '__gt__',
194            '__hash__',
195            '__init__',
196            '__init_subclass__',
197            '__le__',
198            '__lt__',
199            '__module__',
200            '__ne__',
201            '__new__',
202            '__reduce__',
203            '__reduce_ex__',
204            '__repr__',
205            '__setattr__',
206            '__sizeof__',
207            '__static_attributes__',
208            '__str__',
209            '__subclasshook__',
210            '__weakref__',
211            'say_hello'
212        ]
213        assert reality == my_expectation
214        self.assertEqual(reality, my_expectation)
215
216    def test_dir_person_instance(self):
217        an_instance_of_person = src.person.Person(
218            first_name='first_name',
219            last_name='last_name',
220            sex='M',
221            year_of_birth=2026,
222        )
223
224        reality = dir(an_instance_of_person)
225        my_expectation = [
226            '__class__',
227            '__delattr__',
228            '__dict__',
229            '__dir__',
230            '__doc__',
231            '__eq__',
232            '__firstlineno__',
233            '__format__',
234            '__ge__',
235            '__getattribute__',
236            '__getstate__',
237            '__gt__',
238            '__hash__',
239            '__init__',
240            '__init_subclass__',
241            '__le__',
242            '__lt__',
243            '__module__',
244            '__ne__',
245            '__new__',
246            '__reduce__',
247            '__reduce_ex__',
248            '__repr__',
249            '__setattr__',
250            '__sizeof__',
251            '__static_attributes__',
252            '__str__',
253            '__subclasshook__',
254            '__weakref__',
255            'first_name',
256            'last_name',
257            'say_hello',
258            'sex',
259            'year_of_birth',
260        ]
261        assert reality == my_expectation
262        self.assertEqual(reality, my_expectation)
263
264
265# Exceptions seen
266# AssertionError
267# NameError
268# TypeError
269# AttributeError
270# SyntaxError

test telephone with unittest: tests

The code in telephone/tests/test_telephone.py from test telephone with unittest

  1import src.telephone
  2import unittest
  3
  4
  5class TestTelephone(unittest.TestCase):
  6
  7    def test_passing_none(self):
  8        reality = src.telephone.text(None)
  9        my_expectation = 'I got: None'
 10        assert reality == my_expectation
 11        self.assertEqual(reality, my_expectation)
 12
 13    def test_passing_booleans(self):
 14        reality = src.telephone.text(False)
 15        my_expectation = 'I got: False'
 16        assert reality == my_expectation
 17        self.assertEqual(reality, my_expectation)
 18
 19        reality = src.telephone.text(True)
 20        my_expectation = 'I got: True'
 21        assert reality == my_expectation
 22        self.assertEqual(reality, my_expectation)
 23
 24    def test_passing_an_integer(self):
 25        an_integer = 1234
 26
 27        reality = src.telephone.text(an_integer)
 28        my_expectation = f'I got: {an_integer}'
 29        assert reality == my_expectation
 30        self.assertEqual(reality, my_expectation)
 31
 32    def test_passing_a_float(self):
 33        a_float = 5.678
 34
 35        reality = src.telephone.text(a_float)
 36        my_expectation = f'I got: {a_float}'
 37        assert reality == my_expectation
 38        self.assertEqual(reality, my_expectation)
 39
 40    def test_passing_a_string(self):
 41        a_string = 'hello'
 42
 43        reality = src.telephone.text(a_string)
 44        my_expectation = f'I got: {a_string}'
 45        assert reality == my_expectation
 46        self.assertEqual(reality, my_expectation)
 47
 48    def test_passing_a_tuple(self):
 49        a_tuple = (0, 1, 2, 'n')
 50
 51        reality = src.telephone.text(a_tuple)
 52        my_expectation = f'I got: {a_tuple}'
 53        assert reality == my_expectation
 54        self.assertEqual(reality, my_expectation)
 55
 56    def test_passing_a_list(self):
 57        a_list = [0, 1, 2, 'n']
 58
 59        reality = src.telephone.text(a_list)
 60        my_expectation = f'I got: {a_list}'
 61        assert reality == my_expectation
 62        self.assertEqual(reality, my_expectation)
 63
 64    def test_passing_a_set(self):
 65        a_set = {0, 1, 2, 'n'}
 66
 67        reality = src.telephone.text(a_set)
 68        my_expectation = f'I got: {a_set}'
 69        assert reality == my_expectation
 70        self.assertEqual(reality, my_expectation)
 71
 72    def test_passing_a_dictionary(self):
 73        a_dictionary = {
 74            'key0': 'value0',
 75            'keyN': [0, 1, 2, 'n'],
 76        }
 77
 78        reality = src.telephone.text(a_dictionary)
 79        my_expectation = f'I got: {a_dictionary}'
 80        assert reality == my_expectation
 81        self.assertEqual(reality, my_expectation)
 82
 83    def test_passing_a_class(self):
 84        reality = src.telephone.text(object)
 85        my_expectation = "I got: <class 'object'>"
 86        assert reality == my_expectation
 87        self.assertEqual(reality, my_expectation)
 88
 89        reality = src.telephone.text(bool)
 90        my_expectation = "I got: <class 'bool'>"
 91        assert reality == my_expectation
 92        self.assertEqual(reality, my_expectation)
 93
 94        reality = src.telephone.text(int)
 95        my_expectation = "I got: <class 'int'>"
 96        assert reality == my_expectation
 97        self.assertEqual(reality, my_expectation)
 98
 99        reality = src.telephone.text(float)
100        my_expectation = "I got: <class 'float'>"
101        assert reality == my_expectation
102        self.assertEqual(reality, my_expectation)
103
104        reality = src.telephone.text(str)
105        my_expectation = "I got: <class 'str'>"
106        assert reality == my_expectation
107        self.assertEqual(reality, my_expectation)
108
109        reality = src.telephone.text(tuple)
110        my_expectation = "I got: <class 'tuple'>"
111        assert reality == my_expectation
112        self.assertEqual(reality, my_expectation)
113
114        reality = src.telephone.text(list)
115        my_expectation = "I got: <class 'list'>"
116        assert reality == my_expectation
117        self.assertEqual(reality, my_expectation)
118
119        reality = src.telephone.text(set)
120        my_expectation = "I got: <class 'set'>"
121        assert reality == my_expectation
122        self.assertEqual(reality, my_expectation)
123
124        reality = src.telephone.text(dict)
125        my_expectation = "I got: <class 'dict'>"
126        assert reality == my_expectation
127        self.assertEqual(reality, my_expectation)
128
129
130# Exceptions seen
131# AssertionError
132# NameError
133# TypeError
134# ModuleNotFoundError
135# AttributeError