what is None?: tests

None (the simplest object): tests

the code in none/tests/test_none.py from what is None?

 1import unittest
 2
 3
 4class TestNone(unittest.TestCase):
 5
 6    def test_what_is_none(self):
 7        self.assertIs(None, None)
 8        self.assertIsNone(None)
 9
10    def test_is_none_a_boolean(self):
11        self.assertIsNotNone(False)
12        self.assertIsNotNone(True)
13        self.assertIsInstance(False, bool)
14        self.assertIsInstance(True, bool)
15        self.assertNotIsInstance(None, bool)
16
17    def test_is_none_an_integer(self):
18        self.assertIsNotNone(-1)
19        self.assertIsNotNone(0)
20        self.assertIsNotNone(1)
21        self.assertIsInstance(-1, int)
22        self.assertIsInstance(0, int)
23        self.assertIsInstance(1, int)
24        self.assertNotIsInstance(None, int)
25
26    def test_is_none_a_float(self):
27        self.assertIsNotNone(-0.1)
28        self.assertIsNotNone(0.0)
29        self.assertIsNotNone(0.1)
30        self.assertIsInstance(-0.1, float)
31        self.assertIsInstance(0.0, float)
32        self.assertIsInstance(0.1, float)
33        self.assertNotIsInstance(None, float)
34
35    def test_is_none_a_string(self):
36        self.assertIsNotNone('')
37        self.assertIsNotNone("characters")
38        self.assertIsInstance("", str)
39        self.assertIsInstance('characters', str)
40        self.assertNotIsInstance(None, str)
41
42    def test_is_none_a_tuple(self):
43        self.assertIsNotNone(())
44        self.assertIsNotNone((0, 1, 2, 'n'))
45        self.assertIsInstance((), tuple)
46        self.assertIsInstance((0, 1, 2, 'n'), tuple)
47        self.assertNotIsInstance(None, tuple)
48
49    def test_is_none_a_list(self):
50        self.assertIsNotNone([])
51        self.assertIsNotNone([0, 1, 2, 'n'])
52        self.assertIsInstance([], list)
53        self.assertIsInstance([0, 1, 2, 'n'], list)
54        self.assertNotIsInstance(None, list)
55
56    def test_is_none_a_set(self):
57        self.assertIsNotNone(set())
58        self.assertIsNotNone({0, 1, 2, 'n'})
59        self.assertIsInstance({0, 1, 2, 'n'}, set)
60        self.assertNotIsInstance(None, set)
61
62    def test_is_none_a_dictionary(self):
63        self.assertIsNotNone(dict())
64        self.assertIsNotNone({'key': 'value'})
65        self.assertIsInstance({}, dict)
66        self.assertIsInstance(
67            {'key': 'value'}, dict
68        )
69        self.assertNotIsInstance(None, dict)
70
71
72# NOTES
73# None is NOT a dictionary
74# None is NOT a set
75# None is NOT a list
76# None is NOT a tuple
77# None is NOT a string
78# None is NOT a float
79# None is NOT an integer
80# None is NOT a boolean
81# None is None
82
83
84# Exceptions seen
85# AssertionError

test AssertionError with assertIsNotNone and assertIsNone: tests

the code in assertion_error/tests/test_assertion_error.py from test AssertionError with assertIsNotNone and assertIsNone

  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        self.assertIsNone(None)
 34
 35        assert False is not None
 36        self.assertIsNot(False, None)
 37        self.assertIsNotNone(False)
 38
 39        assert True is not None
 40        self.assertIsNot(True, None)
 41        self.assertIsNotNone(True)
 42
 43        assert self.an_integer is not None
 44        self.assertIsNot(self.an_integer, None)
 45        self.assertIsNotNone(self.an_integer)
 46
 47        assert self.a_float is not None
 48        self.assertIsNot(self.a_float, None)
 49        self.assertIsNotNone(self.a_float)
 50
 51        assert self.a_string is not None
 52        self.assertIsNot(self.a_string, None)
 53        self.assertIsNotNone(self.a_string)
 54
 55        assert self.a_tuple is not None
 56        self.assertIsNot(self.a_tuple, None)
 57        self.assertIsNotNone(self.a_tuple)
 58
 59        assert self.a_list is not None
 60        self.assertIsNot(self.a_list, None)
 61        self.assertIsNotNone(self.a_list)
 62
 63        assert self.a_set is not None
 64        self.assertIsNot(self.a_set, None)
 65        self.assertIsNotNone(self.a_set)
 66
 67        assert self.a_dictionary is not None
 68        self.assertIsNot(self.a_dictionary, None)
 69        self.assertIsNotNone(self.a_dictionary)
 70
 71    def test_assertion_error_w_false(self):
 72        assert None is not False
 73        self.assertIsNot(None, False)
 74
 75        assert False is False
 76        self.assertIs(False, False)
 77
 78        assert True is not False
 79        self.assertIsNot(True, False)
 80
 81        assert self.an_integer is not False
 82        self.assertIsNot(self.an_integer, False)
 83
 84        assert self.a_float is not False
 85        self.assertIsNot(self.a_float, False)
 86
 87        assert self.a_string is not False
 88        self.assertIsNot(self.a_string, False)
 89
 90        assert self.a_tuple is not False
 91        self.assertIsNot(self.a_tuple, False)
 92
 93        assert self.a_list is not False
 94        self.assertIsNot(self.a_list, False)
 95
 96        assert self.a_set is not False
 97        self.assertIsNot(self.a_set, False)
 98
 99        assert self.a_dictionary is not False
100        self.assertIsNot(self.a_dictionary, False)
101
102    def test_assertion_error_w_true(self):
103        assert None is not True
104        self.assertIsNot(None, True)
105
106        assert False is not True
107        self.assertIsNot(False, True)
108
109        assert True is True
110        self.assertIs(True, True)
111
112        assert self.an_integer is not True
113        self.assertIsNot(self.an_integer, True)
114
115        assert self.a_float is not True
116        self.assertIsNot(self.a_float, True)
117
118        assert self.a_string is not True
119        self.assertIsNot(self.a_string, True)
120
121        assert self.a_tuple is not True
122        self.assertIsNot(self.a_tuple, True)
123
124        assert self.a_list is not True
125        self.assertIsNot(self.a_list, True)
126
127        assert self.a_set is not True
128        self.assertIsNot(self.a_set, True)
129
130        assert self.a_dictionary is not True
131        self.assertIsNot(self.a_dictionary, True)
132
133    def test_assertion_error_w_equality(self):
134        assert None == None
135        self.assertEqual(None, None)
136
137        assert False != None
138        self.assertNotEqual(False, None)
139
140        assert False != True
141        self.assertNotEqual(False, True)
142
143        assert False == False
144        self.assertEqual(False, False)
145
146        assert True != None
147        self.assertNotEqual(True, None)
148
149        assert True == True
150        self.assertEqual(True, True)
151
152    def test_assertion_error_w_is_vs_equal(self):
153        assert 0 is not 0.0
154        self.assertIsNot(0, 0.0)
155
156        assert 0 == 0.0
157        self.assertEqual(0, 0.0)
158
159    def will_not_run():
160        assert False == True
161        self.assertEqual(False, True)
162
163    def test_failure(self):
164        assert False == False
165        self.assertEqual(False, False)
166
167
168# NOTES
169# a dictionary is not True
170# a dictionary is not False
171# a dictionary is not None
172# a set is not True
173# a set is not False
174# a set is not None
175# a list is not True
176# a list is not False
177# a list is not None
178# a tuple is not True
179# a tuple is not False
180# a tuple is not None
181# a string is not True
182# a string is not False
183# a string is not None
184# a float is not True
185# a float is not False
186# a float is not None
187# an integer is not True
188# an integer is not False
189# an integer is not None
190# True is True and equal to True
191# True is not False and NOT equal to False
192# True is not None and NOT equal to None
193# False is not True and NOT equal to True
194# False is False and equal to False
195# False is not None and NOT equal to None
196# None is not True and NOT equal to True
197# None is not False and NOT equal to False
198# None is None and equal to None
199
200
201# Exceptions seen
202# AssertionError
203# AttributeError
204# NameError
205# TypeError

test functions with assertIsNotNone and assertIsNone

the code in functions/tests/test_functions.py from test functions with assertIsNotNone and assertIsNone