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