test_bool.py revision d59da4b4325d189b93f1d46405b97f2435094699 
1# Test properties of bool promised by PEP 285
2
3import unittest
4from test import test_support
5
6import os
7
8class BoolTest(unittest.TestCase):
9
10    def assertIs(self, a, b):
11        self.assert_(a is b)
12
13    def assertIsNot(self, a, b):
14        self.assert_(a is not b)
15
16    def test_subclass(self):
17        try:
18            class C(bool):
19                pass
20        except TypeError:
21            pass
22        else:
23            self.fail("bool should not be subclassable")
24
25        self.assertRaises(TypeError, int.__new__, bool, 0)
26
27    def test_print(self):
28        try:
29            fo = open(test_support.TESTFN, "wb")
30            print(False, True, file=fo)
31            fo.close()
32            fo = open(test_support.TESTFN, "rb")
33            self.assertEqual(fo.read(), 'False True\n')
34        finally:
35            fo.close()
36            os.remove(test_support.TESTFN)
37
38    def test_repr(self):
39        self.assertEqual(repr(False), 'False')
40        self.assertEqual(repr(True), 'True')
41        self.assertEqual(eval(repr(False)), False)
42        self.assertEqual(eval(repr(True)), True)
43
44    def test_str(self):
45        self.assertEqual(str(False), 'False')
46        self.assertEqual(str(True), 'True')
47
48    def test_int(self):
49        self.assertEqual(int(False), 0)
50        self.assertIsNot(int(False), False)
51        self.assertEqual(int(True), 1)
52        self.assertIsNot(int(True), True)
53
54    def test_math(self):
55        self.assertEqual(+False, 0)
56        self.assertIsNot(+False, False)
57        self.assertEqual(-False, 0)
58        self.assertIsNot(-False, False)
59        self.assertEqual(abs(False), 0)
60        self.assertIsNot(abs(False), False)
61        self.assertEqual(+True, 1)
62        self.assertIsNot(+True, True)
63        self.assertEqual(-True, -1)
64        self.assertEqual(abs(True), 1)
65        self.assertIsNot(abs(True), True)
66        self.assertEqual(~False, -1)
67        self.assertEqual(~True, -2)
68
69        self.assertEqual(False+2, 2)
70        self.assertEqual(True+2, 3)
71        self.assertEqual(2+False, 2)
72        self.assertEqual(2+True, 3)
73
74        self.assertEqual(False+False, 0)
75        self.assertIsNot(False+False, False)
76        self.assertEqual(False+True, 1)
77        self.assertIsNot(False+True, True)
78        self.assertEqual(True+False, 1)
79        self.assertIsNot(True+False, True)
80        self.assertEqual(True+True, 2)
81
82        self.assertEqual(True-True, 0)
83        self.assertIsNot(True-True, False)
84        self.assertEqual(False-False, 0)
85        self.assertIsNot(False-False, False)
86        self.assertEqual(True-False, 1)
87        self.assertIsNot(True-False, True)
88        self.assertEqual(False-True, -1)
89
90        self.assertEqual(True*1, 1)
91        self.assertEqual(False*1, 0)
92        self.assertIsNot(False*1, False)
93
94        self.assertEqual(True/1, 1)
95        self.assertIsNot(True/1, True)
96        self.assertEqual(False/1, 0)
97        self.assertIsNot(False/1, False)
98
99        for b in False, True:
100            for i in 0, 1, 2:
101                self.assertEqual(b**i, int(b)**i)
102                self.assertIsNot(b**i, bool(int(b)**i))
103
104        for a in False, True:
105            for b in False, True:
106                self.assertIs(a&b, bool(int(a)&int(b)))
107                self.assertIs(a|b, bool(int(a)|int(b)))
108                self.assertIs(a^b, bool(int(a)^int(b)))
109                self.assertEqual(a&int(b), int(a)&int(b))
110                self.assertIsNot(a&int(b), bool(int(a)&int(b)))
111                self.assertEqual(a|int(b), int(a)|int(b))
112                self.assertIsNot(a|int(b), bool(int(a)|int(b)))
113                self.assertEqual(a^int(b), int(a)^int(b))
114                self.assertIsNot(a^int(b), bool(int(a)^int(b)))
115                self.assertEqual(int(a)&b, int(a)&int(b))
116                self.assertIsNot(int(a)&b, bool(int(a)&int(b)))
117                self.assertEqual(int(a)|b, int(a)|int(b))
118                self.assertIsNot(int(a)|b, bool(int(a)|int(b)))
119                self.assertEqual(int(a)^b, int(a)^int(b))
120                self.assertIsNot(int(a)^b, bool(int(a)^int(b)))
121
122        self.assertIs(1==1, True)
123        self.assertIs(1==0, False)
124        self.assertIs(0<1, True)
125        self.assertIs(1<0, False)
126        self.assertIs(0<=0, True)
127        self.assertIs(1<=0, False)
128        self.assertIs(1>0, True)
129        self.assertIs(1>1, False)
130        self.assertIs(1>=1, True)
131        self.assertIs(0>=1, False)
132        self.assertIs(0!=1, True)
133        self.assertIs(0!=0, False)
134
135        x = [1]
136        self.assertIs(x is x, True)
137        self.assertIs(x is not x, False)
138
139        self.assertIs(1 in x, True)
140        self.assertIs(0 in x, False)
141        self.assertIs(1 not in x, False)
142        self.assertIs(0 not in x, True)
143
144        x = {1: 2}
145        self.assertIs(x is x, True)
146        self.assertIs(x is not x, False)
147
148        self.assertIs(1 in x, True)
149        self.assertIs(0 in x, False)
150        self.assertIs(1 not in x, False)
151        self.assertIs(0 not in x, True)
152
153        self.assertIs(not True, False)
154        self.assertIs(not False, True)
155
156    def test_convert(self):
157        self.assertRaises(TypeError, bool, 42, 42)
158        self.assertIs(bool(10), True)
159        self.assertIs(bool(1), True)
160        self.assertIs(bool(-1), True)
161        self.assertIs(bool(0), False)
162        self.assertIs(bool("hello"), True)
163        self.assertIs(bool(""), False)
164        self.assertIs(bool(), False)
165
166    def test_hasattr(self):
167        self.assertIs(hasattr([], "append"), True)
168        self.assertIs(hasattr([], "wobble"), False)
169
170    def test_callable(self):
171        self.assertIs(hasattr(len, '__call__'), True)
172        self.assertIs(hasattr(1, '__call__'), False)
173
174    def test_isinstance(self):
175        self.assertIs(isinstance(True, bool), True)
176        self.assertIs(isinstance(False, bool), True)
177        self.assertIs(isinstance(True, int), True)
178        self.assertIs(isinstance(False, int), True)
179        self.assertIs(isinstance(1, bool), False)
180        self.assertIs(isinstance(0, bool), False)
181
182    def test_issubclass(self):
183        self.assertIs(issubclass(bool, int), True)
184        self.assertIs(issubclass(int, bool), False)
185
186    def test_contains(self):
187        self.assertIs(1 in {}, False)
188        self.assertIs(1 in {1:1}, True)
189
190    def test_string(self):
191        self.assertIs("xyz".endswith("z"), True)
192        self.assertIs("xyz".endswith("x"), False)
193        self.assertIs("xyz0123".isalnum(), True)
194        self.assertIs("@#$%".isalnum(), False)
195        self.assertIs("xyz".isalpha(), True)
196        self.assertIs("@#$%".isalpha(), False)
197        self.assertIs("0123".isdigit(), True)
198        self.assertIs("xyz".isdigit(), False)
199        self.assertIs("xyz".islower(), True)
200        self.assertIs("XYZ".islower(), False)
201        self.assertIs("0123".isdecimal(), True)
202        self.assertIs("xyz".isdecimal(), False)
203        self.assertIs("0123".isnumeric(), True)
204        self.assertIs("xyz".isnumeric(), False)
205        self.assertIs(" ".isspace(), True)
206        self.assertIs("\xa0".isspace(), True)
207        self.assertIs("\u3000".isspace(), True)
208        self.assertIs("XYZ".isspace(), False)
209        self.assertIs("X".istitle(), True)
210        self.assertIs("x".istitle(), False)
211        self.assertIs("XYZ".isupper(), True)
212        self.assertIs("xyz".isupper(), False)
213        self.assertIs("xyz".startswith("x"), True)
214        self.assertIs("xyz".startswith("z"), False)
215
216    def test_boolean(self):
217        self.assertEqual(True & 1, 1)
218        self.assert_(not isinstance(True & 1, bool))
219        self.assertIs(True & True, True)
220
221        self.assertEqual(True | 1, 1)
222        self.assert_(not isinstance(True | 1, bool))
223        self.assertIs(True | True, True)
224
225        self.assertEqual(True ^ 1, 0)
226        self.assert_(not isinstance(True ^ 1, bool))
227        self.assertIs(True ^ True, False)
228
229    def test_fileclosed(self):
230        try:
231            f = open(test_support.TESTFN, "w")
232            self.assertIs(f.closed, False)
233            f.close()
234            self.assertIs(f.closed, True)
235        finally:
236            os.remove(test_support.TESTFN)
237
238    def test_operator(self):
239        import operator
240        self.assertIs(operator.truth(0), False)
241        self.assertIs(operator.truth(1), True)
242        self.assertIs(operator.isNumberType(None), False)
243        self.assertIs(operator.isNumberType(0), True)
244        self.assertIs(operator.not_(1), False)
245        self.assertIs(operator.not_(0), True)
246        self.assertIs(operator.isSequenceType(0), False)
247        self.assertIs(operator.isSequenceType([]), True)
248        self.assertIs(operator.contains([], 1), False)
249        self.assertIs(operator.contains([1], 1), True)
250        self.assertIs(operator.isMappingType(1), False)
251        self.assertIs(operator.isMappingType({}), True)
252        self.assertIs(operator.lt(0, 0), False)
253        self.assertIs(operator.lt(0, 1), True)
254        self.assertIs(operator.is_(True, True), True)
255        self.assertIs(operator.is_(True, False), False)
256        self.assertIs(operator.is_not(True, True), False)
257        self.assertIs(operator.is_not(True, False), True)
258
259    def test_marshal(self):
260        import marshal
261        self.assertIs(marshal.loads(marshal.dumps(True)), True)
262        self.assertIs(marshal.loads(marshal.dumps(False)), False)
263
264    def test_pickle(self):
265        import pickle
266        self.assertIs(pickle.loads(pickle.dumps(True)), True)
267        self.assertIs(pickle.loads(pickle.dumps(False)), False)
268        self.assertIs(pickle.loads(pickle.dumps(True, True)), True)
269        self.assertIs(pickle.loads(pickle.dumps(False, True)), False)
270
271    def test_cpickle(self):
272        try:
273            import cPickle
274        except ImportError:
275            return # Just ignore this if cPickle doesn't exist
276
277        self.assertIs(cPickle.loads(cPickle.dumps(True)), True)
278        self.assertIs(cPickle.loads(cPickle.dumps(False)), False)
279        self.assertIs(cPickle.loads(cPickle.dumps(True, True)), True)
280        self.assertIs(cPickle.loads(cPickle.dumps(False, True)), False)
281
282    def test_mixedpickle(self):
283        import pickle
284        try:
285            import cPickle
286        except ImportError:
287            return # Just ignore this if cPickle doesn't exist
288
289        self.assertIs(pickle.loads(cPickle.dumps(True)), True)
290        self.assertIs(pickle.loads(cPickle.dumps(False)), False)
291        self.assertIs(pickle.loads(cPickle.dumps(True, True)), True)
292        self.assertIs(pickle.loads(cPickle.dumps(False, True)), False)
293
294        self.assertIs(cPickle.loads(pickle.dumps(True)), True)
295        self.assertIs(cPickle.loads(pickle.dumps(False)), False)
296        self.assertIs(cPickle.loads(pickle.dumps(True, True)), True)
297        self.assertIs(cPickle.loads(pickle.dumps(False, True)), False)
298
299    def test_picklevalues(self):
300        # Test for specific backwards-compatible pickle values
301        import pickle
302        self.assertEqual(pickle.dumps(True, protocol=0), b"I01\n.")
303        self.assertEqual(pickle.dumps(False, protocol=0), b"I00\n.")
304        self.assertEqual(pickle.dumps(True, protocol=1), b"I01\n.")
305        self.assertEqual(pickle.dumps(False, protocol=1), b"I00\n.")
306        self.assertEqual(pickle.dumps(True, protocol=2), b'\x80\x02\x88.')
307        self.assertEqual(pickle.dumps(False, protocol=2), b'\x80\x02\x89.')
308
309    def test_cpicklevalues(self):
310        # Test for specific backwards-compatible pickle values
311        try:
312            import cPickle
313        except ImportError:
314            return # Just ignore the rest if cPickle doesn't exist
315        self.assertEqual(cPickle.dumps(True, protocol=0), b"I01\n.")
316        self.assertEqual(cPickle.dumps(False, protocol=0), b"I00\n.")
317        self.assertEqual(cPickle.dumps(True, protocol=1), b"I01\n.")
318        self.assertEqual(cPickle.dumps(False, protocol=1), b"I00\n.")
319        self.assertEqual(cPickle.dumps(True, protocol=2), b'\x80\x02\x88.')
320        self.assertEqual(cPickle.dumps(False, protocol=2), b'\x80\x02\x89.')
321
322    def test_convert_to_bool(self):
323        # Verify that TypeError occurs when bad things are returned
324        # from __bool__().  This isn't really a bool test, but
325        # it's related.
326        check = lambda o: self.assertRaises(TypeError, bool, o)
327        class Foo(object):
328            def __bool__(self):
329                return self
330        check(Foo())
331
332        class Bar(object):
333            def __bool__(self):
334                return "Yes"
335        check(Bar())
336
337        class Baz(int):
338            def __bool__(self):
339                return self
340        check(Baz())
341
342        # __bool__() must return a bool not an int
343        class Spam(int):
344            def __bool__(self):
345                return 1
346        check(Spam())
347
348        class Eggs:
349            def __len__(self):
350                return -1
351        self.assertRaises(ValueError, bool, Eggs())
352
353    def test_sane_len(self):
354        # this test just tests our assumptions about __len__
355        # this will start failing if __len__ changes assertions
356        for badval in ['illegal', -1, 1 << 32]:
357            class A:
358                def __len__(self):
359                    return badval
360            try:
361                bool(A())
362            except (Exception) as e_bool:
363                try:
364                    len(A())
365                except (Exception) as e_len:
366                    self.assertEqual(str(e_bool), str(e_len))
367
368def test_main():
369    test_support.run_unittest(BoolTest)
370
371if __name__ == "__main__":
372    test_main()
373