Home | History | Annotate | Download | only in test
      1 # Test properties of bool promised by PEP 285
      2 
      3 import unittest
      4 from test import test_support
      5 
      6 import os
      7 
      8 class 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(test_support.TESTFN, "wb")
     24             print >> fo, False, True
     25             fo.close()
     26             fo = open(test_support.TESTFN, "rb")
     27             self.assertEqual(fo.read(), 'False True\n')
     28         finally:
     29             fo.close()
     30             os.remove(test_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_long(self):
     55         self.assertEqual(long(False), 0L)
     56         self.assertIsNot(long(False), False)
     57         self.assertEqual(long(True), 1L)
     58         self.assertIsNot(long(True), True)
     59 
     60     def test_math(self):
     61         self.assertEqual(+False, 0)
     62         self.assertIsNot(+False, False)
     63         self.assertEqual(-False, 0)
     64         self.assertIsNot(-False, False)
     65         self.assertEqual(abs(False), 0)
     66         self.assertIsNot(abs(False), False)
     67         self.assertEqual(+True, 1)
     68         self.assertIsNot(+True, True)
     69         self.assertEqual(-True, -1)
     70         self.assertEqual(abs(True), 1)
     71         self.assertIsNot(abs(True), True)
     72         self.assertEqual(~False, -1)
     73         self.assertEqual(~True, -2)
     74 
     75         self.assertEqual(False+2, 2)
     76         self.assertEqual(True+2, 3)
     77         self.assertEqual(2+False, 2)
     78         self.assertEqual(2+True, 3)
     79 
     80         self.assertEqual(False+False, 0)
     81         self.assertIsNot(False+False, False)
     82         self.assertEqual(False+True, 1)
     83         self.assertIsNot(False+True, True)
     84         self.assertEqual(True+False, 1)
     85         self.assertIsNot(True+False, True)
     86         self.assertEqual(True+True, 2)
     87 
     88         self.assertEqual(True-True, 0)
     89         self.assertIsNot(True-True, False)
     90         self.assertEqual(False-False, 0)
     91         self.assertIsNot(False-False, False)
     92         self.assertEqual(True-False, 1)
     93         self.assertIsNot(True-False, True)
     94         self.assertEqual(False-True, -1)
     95 
     96         self.assertEqual(True*1, 1)
     97         self.assertEqual(False*1, 0)
     98         self.assertIsNot(False*1, False)
     99 
    100         self.assertEqual(True//1, 1)
    101         self.assertIsNot(True//1, True)
    102         self.assertEqual(False//1, 0)
    103         self.assertIsNot(False//1, False)
    104 
    105         for b in False, True:
    106             for i in 0, 1, 2:
    107                 self.assertEqual(b**i, int(b)**i)
    108                 self.assertIsNot(b**i, bool(int(b)**i))
    109 
    110         for a in False, True:
    111             for b in False, True:
    112                 self.assertIs(a&b, bool(int(a)&int(b)))
    113                 self.assertIs(a|b, bool(int(a)|int(b)))
    114                 self.assertIs(a^b, bool(int(a)^int(b)))
    115                 self.assertEqual(a&int(b), int(a)&int(b))
    116                 self.assertIsNot(a&int(b), bool(int(a)&int(b)))
    117                 self.assertEqual(a|int(b), int(a)|int(b))
    118                 self.assertIsNot(a|int(b), bool(int(a)|int(b)))
    119                 self.assertEqual(a^int(b), int(a)^int(b))
    120                 self.assertIsNot(a^int(b), bool(int(a)^int(b)))
    121                 self.assertEqual(int(a)&b, int(a)&int(b))
    122                 self.assertIsNot(int(a)&b, bool(int(a)&int(b)))
    123                 self.assertEqual(int(a)|b, int(a)|int(b))
    124                 self.assertIsNot(int(a)|b, bool(int(a)|int(b)))
    125                 self.assertEqual(int(a)^b, int(a)^int(b))
    126                 self.assertIsNot(int(a)^b, bool(int(a)^int(b)))
    127 
    128         self.assertIs(1==1, True)
    129         self.assertIs(1==0, False)
    130         self.assertIs(0<1, True)
    131         self.assertIs(1<0, False)
    132         self.assertIs(0<=0, True)
    133         self.assertIs(1<=0, False)
    134         self.assertIs(1>0, True)
    135         self.assertIs(1>1, False)
    136         self.assertIs(1>=1, True)
    137         self.assertIs(0>=1, False)
    138         self.assertIs(0!=1, True)
    139         self.assertIs(0!=0, False)
    140 
    141         x = [1]
    142         self.assertIs(x is x, True)
    143         self.assertIs(x is not x, False)
    144 
    145         self.assertIs(1 in x, True)
    146         self.assertIs(0 in x, False)
    147         self.assertIs(1 not in x, False)
    148         self.assertIs(0 not in x, True)
    149 
    150         x = {1: 2}
    151         self.assertIs(x is x, True)
    152         self.assertIs(x is not x, False)
    153 
    154         self.assertIs(1 in x, True)
    155         self.assertIs(0 in x, False)
    156         self.assertIs(1 not in x, False)
    157         self.assertIs(0 not in x, True)
    158 
    159         self.assertIs(not True, False)
    160         self.assertIs(not False, True)
    161 
    162     def test_convert(self):
    163         self.assertRaises(TypeError, bool, 42, 42)
    164         self.assertIs(bool(10), True)
    165         self.assertIs(bool(1), True)
    166         self.assertIs(bool(-1), True)
    167         self.assertIs(bool(0), False)
    168         self.assertIs(bool("hello"), True)
    169         self.assertIs(bool(""), False)
    170         self.assertIs(bool(), False)
    171 
    172     def test_format(self):
    173         self.assertEqual("%d" % False, "0")
    174         self.assertEqual("%d" % True, "1")
    175         self.assertEqual("%x" % False, "0")
    176         self.assertEqual("%x" % True, "1")
    177 
    178     def test_hasattr(self):
    179         self.assertIs(hasattr([], "append"), True)
    180         self.assertIs(hasattr([], "wobble"), False)
    181 
    182     def test_callable(self):
    183         self.assertIs(callable(len), True)
    184         self.assertIs(callable(1), False)
    185 
    186     def test_isinstance(self):
    187         self.assertIs(isinstance(True, bool), True)
    188         self.assertIs(isinstance(False, bool), True)
    189         self.assertIs(isinstance(True, int), True)
    190         self.assertIs(isinstance(False, int), True)
    191         self.assertIs(isinstance(1, bool), False)
    192         self.assertIs(isinstance(0, bool), False)
    193 
    194     def test_issubclass(self):
    195         self.assertIs(issubclass(bool, int), True)
    196         self.assertIs(issubclass(int, bool), False)
    197 
    198     def test_haskey(self):
    199         self.assertIs(1 in {}, False)
    200         self.assertIs(1 in {1:1}, True)
    201         with test_support.check_py3k_warnings():
    202             self.assertIs({}.has_key(1), False)
    203             self.assertIs({1:1}.has_key(1), True)
    204 
    205     def test_string(self):
    206         self.assertIs("xyz".endswith("z"), True)
    207         self.assertIs("xyz".endswith("x"), False)
    208         self.assertIs("xyz0123".isalnum(), True)
    209         self.assertIs("@#$%".isalnum(), False)
    210         self.assertIs("xyz".isalpha(), True)
    211         self.assertIs("@#$%".isalpha(), False)
    212         self.assertIs("0123".isdigit(), True)
    213         self.assertIs("xyz".isdigit(), False)
    214         self.assertIs("xyz".islower(), True)
    215         self.assertIs("XYZ".islower(), False)
    216         self.assertIs(" ".isspace(), True)
    217         self.assertIs("XYZ".isspace(), False)
    218         self.assertIs("X".istitle(), True)
    219         self.assertIs("x".istitle(), False)
    220         self.assertIs("XYZ".isupper(), True)
    221         self.assertIs("xyz".isupper(), False)
    222         self.assertIs("xyz".startswith("x"), True)
    223         self.assertIs("xyz".startswith("z"), False)
    224 
    225         if test_support.have_unicode:
    226             self.assertIs(unicode("xyz", 'ascii').endswith(unicode("z", 'ascii')), True)
    227             self.assertIs(unicode("xyz", 'ascii').endswith(unicode("x", 'ascii')), False)
    228             self.assertIs(unicode("xyz0123", 'ascii').isalnum(), True)
    229             self.assertIs(unicode("@#$%", 'ascii').isalnum(), False)
    230             self.assertIs(unicode("xyz", 'ascii').isalpha(), True)
    231             self.assertIs(unicode("@#$%", 'ascii').isalpha(), False)
    232             self.assertIs(unicode("0123", 'ascii').isdecimal(), True)
    233             self.assertIs(unicode("xyz", 'ascii').isdecimal(), False)
    234             self.assertIs(unicode("0123", 'ascii').isdigit(), True)
    235             self.assertIs(unicode("xyz", 'ascii').isdigit(), False)
    236             self.assertIs(unicode("xyz", 'ascii').islower(), True)
    237             self.assertIs(unicode("XYZ", 'ascii').islower(), False)
    238             self.assertIs(unicode("0123", 'ascii').isnumeric(), True)
    239             self.assertIs(unicode("xyz", 'ascii').isnumeric(), False)
    240             self.assertIs(unicode(" ", 'ascii').isspace(), True)
    241             self.assertIs(unicode("XYZ", 'ascii').isspace(), False)
    242             self.assertIs(unicode("X", 'ascii').istitle(), True)
    243             self.assertIs(unicode("x", 'ascii').istitle(), False)
    244             self.assertIs(unicode("XYZ", 'ascii').isupper(), True)
    245             self.assertIs(unicode("xyz", 'ascii').isupper(), False)
    246             self.assertIs(unicode("xyz", 'ascii').startswith(unicode("x", 'ascii')), True)
    247             self.assertIs(unicode("xyz", 'ascii').startswith(unicode("z", 'ascii')), False)
    248 
    249     def test_boolean(self):
    250         self.assertEqual(True & 1, 1)
    251         self.assertNotIsInstance(True & 1, bool)
    252         self.assertIs(True & True, True)
    253 
    254         self.assertEqual(True | 1, 1)
    255         self.assertNotIsInstance(True | 1, bool)
    256         self.assertIs(True | True, True)
    257 
    258         self.assertEqual(True ^ 1, 0)
    259         self.assertNotIsInstance(True ^ 1, bool)
    260         self.assertIs(True ^ True, False)
    261 
    262     def test_fileclosed(self):
    263         try:
    264             f = file(test_support.TESTFN, "w")
    265             self.assertIs(f.closed, False)
    266             f.close()
    267             self.assertIs(f.closed, True)
    268         finally:
    269             os.remove(test_support.TESTFN)
    270 
    271     def test_types(self):
    272         # types are always true.
    273         for t in [bool, complex, dict, file, float, int, list, long, object,
    274                   set, str, tuple, type]:
    275             self.assertIs(bool(t), True)
    276 
    277     def test_operator(self):
    278         import operator
    279         self.assertIs(operator.truth(0), False)
    280         self.assertIs(operator.truth(1), True)
    281         with test_support.check_py3k_warnings():
    282             self.assertIs(operator.isCallable(0), False)
    283             self.assertIs(operator.isCallable(len), True)
    284         self.assertIs(operator.isNumberType(None), False)
    285         self.assertIs(operator.isNumberType(0), True)
    286         self.assertIs(operator.not_(1), False)
    287         self.assertIs(operator.not_(0), True)
    288         self.assertIs(operator.isSequenceType(0), False)
    289         self.assertIs(operator.isSequenceType([]), True)
    290         self.assertIs(operator.contains([], 1), False)
    291         self.assertIs(operator.contains([1], 1), True)
    292         self.assertIs(operator.isMappingType(1), False)
    293         self.assertIs(operator.isMappingType({}), True)
    294         self.assertIs(operator.lt(0, 0), False)
    295         self.assertIs(operator.lt(0, 1), True)
    296         self.assertIs(operator.is_(True, True), True)
    297         self.assertIs(operator.is_(True, False), False)
    298         self.assertIs(operator.is_not(True, True), False)
    299         self.assertIs(operator.is_not(True, False), True)
    300 
    301     def test_marshal(self):
    302         import marshal
    303         self.assertIs(marshal.loads(marshal.dumps(True)), True)
    304         self.assertIs(marshal.loads(marshal.dumps(False)), False)
    305 
    306     def test_pickle(self):
    307         import pickle
    308         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
    309             self.assertIs(pickle.loads(pickle.dumps(True, proto)), True)
    310             self.assertIs(pickle.loads(pickle.dumps(False, proto)), False)
    311 
    312     def test_cpickle(self):
    313         import cPickle
    314         for proto in range(cPickle.HIGHEST_PROTOCOL + 1):
    315             self.assertIs(cPickle.loads(cPickle.dumps(True, proto)), True)
    316             self.assertIs(cPickle.loads(cPickle.dumps(False, proto)), False)
    317 
    318     def test_mixedpickle(self):
    319         import pickle, cPickle
    320         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
    321             self.assertIs(pickle.loads(cPickle.dumps(True, proto)), True)
    322             self.assertIs(pickle.loads(cPickle.dumps(False, proto)), False)
    323             self.assertIs(cPickle.loads(pickle.dumps(True, proto)), True)
    324             self.assertIs(cPickle.loads(pickle.dumps(False, proto)), False)
    325 
    326     def test_picklevalues(self):
    327         import pickle, cPickle
    328 
    329         # Test for specific backwards-compatible pickle values
    330         self.assertEqual(pickle.dumps(True, protocol=0), "I01\n.")
    331         self.assertEqual(pickle.dumps(False, protocol=0), "I00\n.")
    332         self.assertEqual(cPickle.dumps(True, protocol=0), "I01\n.")
    333         self.assertEqual(cPickle.dumps(False, protocol=0), "I00\n.")
    334         self.assertEqual(pickle.dumps(True, protocol=1), "I01\n.")
    335         self.assertEqual(pickle.dumps(False, protocol=1), "I00\n.")
    336         self.assertEqual(cPickle.dumps(True, protocol=1), "I01\n.")
    337         self.assertEqual(cPickle.dumps(False, protocol=1), "I00\n.")
    338         self.assertEqual(pickle.dumps(True, protocol=2), b'\x80\x02\x88.')
    339         self.assertEqual(pickle.dumps(False, protocol=2), b'\x80\x02\x89.')
    340         self.assertEqual(cPickle.dumps(True, protocol=2), b'\x80\x02\x88.')
    341         self.assertEqual(cPickle.dumps(False, protocol=2), b'\x80\x02\x89.')
    342 
    343     def test_convert_to_bool(self):
    344         # Verify that TypeError occurs when bad things are returned
    345         # from __nonzero__().  This isn't really a bool test, but
    346         # it's related.
    347         check = lambda o: self.assertRaises(TypeError, bool, o)
    348         class Foo(object):
    349             def __nonzero__(self):
    350                 return self
    351         check(Foo())
    352 
    353         class Bar(object):
    354             def __nonzero__(self):
    355                 return "Yes"
    356         check(Bar())
    357 
    358         class Baz(int):
    359             def __nonzero__(self):
    360                 return self
    361         check(Baz())
    362 
    363 
    364 def test_main():
    365     test_support.run_unittest(BoolTest)
    366 
    367 if __name__ == "__main__":
    368     test_main()
    369