Skip to content

C
cpython
Kaydet (Commit) dbcede5d authored tarafından Walter Dörwald's avatar Walter Dörwald
Dosyalara gözat
Seçenekler

Port test_bool.py to PyUnit. From SF patch #662807.

üst 74bfd70e
Hide whitespace changes
Inline Side-by-side
Showing with 328 additions and 253 deletions
Lib/test/test_bool.py
Dosyayı görüntüle @ dbcede5d
# Test properties of bool promised by PEP 285 # Test properties of bool promised by PEP 285
from test.test_support import verbose, TestFailed, TESTFN, vereq, have_unicode import unittest
from test import test_support
import os import os
from test.test_support import verbose, TestFailed, TESTFN, vereq, have_unicode
def veris(a, b): def veris(a, b):
if a is not b: if a is not b:
raise TestFailed, "%r is %r" % (a, b) raise TestFailed, "%r is %r" % (a, b)
...@@ -11,255 +15,326 @@ def verisnot(a, b): ...@@ -11,255 +15,326 @@ def verisnot(a, b):
if a is b: if a is b:
raise TestFailed, "%r is %r" % (a, b) raise TestFailed, "%r is %r" % (a, b)
try: class BoolTest(unittest.TestCase):
class C(bool):
pass def assertIs(self, a, b):
except TypeError: self.assert_(a is b)
pass
else: def assertIsNot(self, a, b):
raise TestFailed, "bool should not be subclassable" self.assert_(a is not b)
try: def test_subclass(self):
int.__new__(bool, 0) try:
except TypeError: class C(bool):
pass pass
else: except TypeError:
raise TestFailed, "should not be able to create new bool instances" pass
else:
# checking tp_print slot self.fail("bool should not be subclassable")
fo = open(TESTFN, "wb")
print >> fo, False, True self.assertRaises(TypeError, int.__new__, bool, 0)
fo.close()
fo = open(TESTFN, "rb") def test_print(self):
vereq(fo.read(), 'False True\n') try:
fo.close() fo = open(test_support.TESTFN, "wb")
os.remove(TESTFN) print >> fo, False, True
fo.close()
# checking repr and str fo = open(test_support.TESTFN, "rb")
vereq(str(False), 'False') self.assertEqual(fo.read(), 'False True\n')
vereq(str(True), 'True') finally:
vereq(repr(False), 'False') fo.close()
vereq(repr(True), 'True') os.remove(test_support.TESTFN)
vereq(eval(repr(False)), False)
vereq(eval(repr(True)), True) def test_repr(self):
self.assertEqual(repr(False), 'False')
vereq(int(False), 0) self.assertEqual(repr(True), 'True')
verisnot(int(False), False) self.assertEqual(eval(repr(False)), False)
vereq(int(True), 1) self.assertEqual(eval(repr(True)), True)
verisnot(int(True), True)
def test_str(self):
vereq(+False, 0) self.assertEqual(str(False), 'False')
verisnot(+False, False) self.assertEqual(str(True), 'True')
vereq(-False, 0)
verisnot(-False, False) def test_int(self):
vereq(abs(False), 0) self.assertEqual(int(False), 0)
verisnot(abs(False), False) self.assertIsNot(int(False), False)
vereq(+True, 1) self.assertEqual(int(True), 1)
verisnot(+True, True) self.assertIsNot(int(True), True)
vereq(-True, -1)
vereq(abs(True), 1) def test_math(self):
verisnot(abs(True), True) self.assertEqual(+False, 0)
vereq(~False, -1) self.assertIsNot(+False, False)
vereq(~True, -2) self.assertEqual(-False, 0)
self.assertIsNot(-False, False)
vereq(False+2, 2) self.assertEqual(abs(False), 0)
vereq(True+2, 3) self.assertIsNot(abs(False), False)
vereq(2+False, 2) self.assertEqual(+True, 1)
vereq(2+True, 3) self.assertIsNot(+True, True)
self.assertEqual(-True, -1)
vereq(False+False, 0) self.assertEqual(abs(True), 1)
verisnot(False+False, False) self.assertIsNot(abs(True), True)
vereq(False+True, 1) self.assertEqual(~False, -1)
verisnot(False+True, True) self.assertEqual(~True, -2)
vereq(True+False, 1)
verisnot(True+False, True) self.assertEqual(False+2, 2)
vereq(True+True, 2) self.assertEqual(True+2, 3)
self.assertEqual(2+False, 2)
vereq(True-True, 0) self.assertEqual(2+True, 3)
verisnot(True-True, False)
vereq(False-False, 0) self.assertEqual(False+False, 0)
verisnot(False-False, False) self.assertIsNot(False+False, False)
vereq(True-False, 1) self.assertEqual(False+True, 1)
verisnot(True-False, True) self.assertIsNot(False+True, True)
vereq(False-True, -1) self.assertEqual(True+False, 1)
self.assertIsNot(True+False, True)
vereq(True*1, 1) self.assertEqual(True+True, 2)
vereq(False*1, 0)
verisnot(False*1, False) self.assertEqual(True-True, 0)
self.assertIsNot(True-True, False)
vereq(True/1, 1) self.assertEqual(False-False, 0)
verisnot(True/1, True) self.assertIsNot(False-False, False)
vereq(False/1, 0) self.assertEqual(True-False, 1)
verisnot(False/1, False) self.assertIsNot(True-False, True)
self.assertEqual(False-True, -1)
for b in False, True:
for i in 0, 1, 2: self.assertEqual(True*1, 1)
vereq(b**i, int(b)**i) self.assertEqual(False*1, 0)
verisnot(b**i, bool(int(b)**i)) self.assertIsNot(False*1, False)
for a in False, True: self.assertEqual(True/1, 1)
for b in False, True: self.assertIsNot(True/1, True)
veris(a&b, bool(int(a)&int(b))) self.assertEqual(False/1, 0)
veris(a|b, bool(int(a)|int(b))) self.assertIsNot(False/1, False)
veris(a^b, bool(int(a)^int(b)))
vereq(a&int(b), int(a)&int(b)) for b in False, True:
verisnot(a&int(b), bool(int(a)&int(b))) for i in 0, 1, 2:
vereq(a|int(b), int(a)|int(b)) self.assertEqual(b**i, int(b)**i)
verisnot(a|int(b), bool(int(a)|int(b))) self.assertIsNot(b**i, bool(int(b)**i))
vereq(a^int(b), int(a)^int(b))
verisnot(a^int(b), bool(int(a)^int(b))) for a in False, True:
vereq(int(a)&b, int(a)&int(b)) for b in False, True:
verisnot(int(a)&b, bool(int(a)&int(b))) self.assertIs(a&b, bool(int(a)&int(b)))
vereq(int(a)|b, int(a)|int(b)) self.assertIs(a|b, bool(int(a)|int(b)))
verisnot(int(a)|b, bool(int(a)|int(b))) self.assertIs(a^b, bool(int(a)^int(b)))
vereq(int(a)^b, int(a)^int(b)) self.assertEqual(a&int(b), int(a)&int(b))
verisnot(int(a)^b, bool(int(a)^int(b))) self.assertIsNot(a&int(b), bool(int(a)&int(b)))
self.assertEqual(a|int(b), int(a)|int(b))
veris(1==1, True) self.assertIsNot(a|int(b), bool(int(a)|int(b)))
veris(1==0, False) self.assertEqual(a^int(b), int(a)^int(b))
# XXX <, <=, >, >=, != self.assertIsNot(a^int(b), bool(int(a)^int(b)))
self.assertEqual(int(a)&b, int(a)&int(b))
x = [1] self.assertIsNot(int(a)&b, bool(int(a)&int(b)))
veris(x is x, True) self.assertEqual(int(a)|b, int(a)|int(b))
veris(x is not x, False) self.assertIsNot(int(a)|b, bool(int(a)|int(b)))
self.assertEqual(int(a)^b, int(a)^int(b))
veris(1 in x, True) self.assertIsNot(int(a)^b, bool(int(a)^int(b)))
veris(0 in x, False)
veris(1 not in x, False) self.assertIs(1==1, True)
veris(0 not in x, True) self.assertIs(1==0, False)
self.assertIs(0<1, True)
veris(not True, False) self.assertIs(1<0, False)
veris(not False, True) self.assertIs(0<=0, True)
self.assertIs(1<=0, False)
veris(bool(10), True) self.assertIs(1>0, True)
veris(bool(1), True) self.assertIs(1>1, False)
veris(bool(-1), True) self.assertIs(1>=1, True)
veris(bool(0), False) self.assertIs(0>=1, False)
veris(bool("hello"), True) self.assertIs(0!=1, True)
veris(bool(""), False) self.assertIs(0!=0, False)
veris(bool(), False)
x = [1]
veris(hasattr([], "append"), True) self.assertIs(x is x, True)
veris(hasattr([], "wobble"), False) self.assertIs(x is not x, False)
veris(callable(len), True) self.assertIs(1 in x, True)
veris(callable(1), False) self.assertIs(0 in x, False)
self.assertIs(1 not in x, False)
veris(isinstance(True, bool), True) self.assertIs(0 not in x, True)
veris(isinstance(False, bool), True)
veris(isinstance(True, int), True) x = {1: 2}
veris(isinstance(False, int), True) self.assertIs(x is x, True)
veris(isinstance(1, bool), False) self.assertIs(x is not x, False)
veris(isinstance(0, bool), False)
self.assertIs(1 in x, True)
veris(issubclass(bool, int), True) self.assertIs(0 in x, False)
veris(issubclass(int, bool), False) self.assertIs(1 not in x, False)
self.assertIs(0 not in x, True)
veris({}.has_key(1), False)
veris({1:1}.has_key(1), True) self.assertIs(not True, False)
self.assertIs(not False, True)
veris("xyz".endswith("z"), True)
veris("xyz".endswith("x"), False) def test_convert(self):
veris("xyz0123".isalnum(), True) self.assertRaises(TypeError, bool, 42, 42)
veris("@#$%".isalnum(), False) self.assertIs(bool(10), True)
veris("xyz".isalpha(), True) self.assertIs(bool(1), True)
veris("@#$%".isalpha(), False) self.assertIs(bool(-1), True)
veris("0123".isdigit(), True) self.assertIs(bool(0), False)
veris("xyz".isdigit(), False) self.assertIs(bool("hello"), True)
veris("xyz".islower(), True) self.assertIs(bool(""), False)
veris("XYZ".islower(), False) self.assertIs(bool(), False)
veris(" ".isspace(), True)
veris("XYZ".isspace(), False) def test_hasattr(self):
veris("X".istitle(), True) self.assertIs(hasattr([], "append"), True)
veris("x".istitle(), False) self.assertIs(hasattr([], "wobble"), False)
veris("XYZ".isupper(), True)
veris("xyz".isupper(), False) def test_callable(self):
veris("xyz".startswith("x"), True) self.assertIs(callable(len), True)
veris("xyz".startswith("z"), False) self.assertIs(callable(1), False)
if have_unicode: def test_isinstance(self):
veris(unicode("xyz", 'ascii').endswith(unicode("z", 'ascii')), True) self.assertIs(isinstance(True, bool), True)
veris(unicode("xyz", 'ascii').endswith(unicode("x", 'ascii')), False) self.assertIs(isinstance(False, bool), True)
veris(unicode("xyz0123", 'ascii').isalnum(), True) self.assertIs(isinstance(True, int), True)
veris(unicode("@#$%", 'ascii').isalnum(), False) self.assertIs(isinstance(False, int), True)
veris(unicode("xyz", 'ascii').isalpha(), True) self.assertIs(isinstance(1, bool), False)
veris(unicode("@#$%", 'ascii').isalpha(), False) self.assertIs(isinstance(0, bool), False)
veris(unicode("0123", 'ascii').isdecimal(), True)
veris(unicode("xyz", 'ascii').isdecimal(), False) def test_issubclass(self):
veris(unicode("0123", 'ascii').isdigit(), True) self.assertIs(issubclass(bool, int), True)
veris(unicode("xyz", 'ascii').isdigit(), False) self.assertIs(issubclass(int, bool), False)
veris(unicode("xyz", 'ascii').islower(), True)
veris(unicode("XYZ", 'ascii').islower(), False) def test_haskey(self):
veris(unicode("0123", 'ascii').isnumeric(), True) self.assertIs({}.has_key(1), False)
veris(unicode("xyz", 'ascii').isnumeric(), False) self.assertIs({1:1}.has_key(1), True)
veris(unicode(" ", 'ascii').isspace(), True)
veris(unicode("XYZ", 'ascii').isspace(), False) def test_string(self):
veris(unicode("X", 'ascii').istitle(), True) self.assertIs("xyz".endswith("z"), True)
veris(unicode("x", 'ascii').istitle(), False) self.assertIs("xyz".endswith("x"), False)
veris(unicode("XYZ", 'ascii').isupper(), True) self.assertIs("xyz0123".isalnum(), True)
veris(unicode("xyz", 'ascii').isupper(), False) self.assertIs("@#$%".isalnum(), False)
veris(unicode("xyz", 'ascii').startswith(unicode("x", 'ascii')), True) self.assertIs("xyz".isalpha(), True)
veris(unicode("xyz", 'ascii').startswith(unicode("z", 'ascii')), False) self.assertIs("@#$%".isalpha(), False)
self.assertIs("0123".isdigit(), True)
f = file(TESTFN, "w") self.assertIs("xyz".isdigit(), False)
veris(f.closed, False) self.assertIs("xyz".islower(), True)
f.close() self.assertIs("XYZ".islower(), False)
veris(f.closed, True) self.assertIs(" ".isspace(), True)
os.remove(TESTFN) self.assertIs("XYZ".isspace(), False)
self.assertIs("X".istitle(), True)
import operator self.assertIs("x".istitle(), False)
veris(operator.truth(0), False) self.assertIs("XYZ".isupper(), True)
veris(operator.truth(1), True) self.assertIs("xyz".isupper(), False)
veris(operator.isCallable(0), False) self.assertIs("xyz".startswith("x"), True)
veris(operator.isCallable(len), True) self.assertIs("xyz".startswith("z"), False)
veris(operator.isNumberType(None), False)
veris(operator.isNumberType(0), True) if have_unicode:
veris(operator.not_(1), False) self.assertIs(unicode("xyz", 'ascii').endswith(unicode("z", 'ascii')), True)
veris(operator.not_(0), True) self.assertIs(unicode("xyz", 'ascii').endswith(unicode("x", 'ascii')), False)
veris(operator.isSequenceType(0), False) self.assertIs(unicode("xyz0123", 'ascii').isalnum(), True)
veris(operator.isSequenceType([]), True) self.assertIs(unicode("@#$%", 'ascii').isalnum(), False)
veris(operator.contains([], 1), False) self.assertIs(unicode("xyz", 'ascii').isalpha(), True)
veris(operator.contains([1], 1), True) self.assertIs(unicode("@#$%", 'ascii').isalpha(), False)
veris(operator.isMappingType(1), False) self.assertIs(unicode("0123", 'ascii').isdecimal(), True)
veris(operator.isMappingType({}), True) self.assertIs(unicode("xyz", 'ascii').isdecimal(), False)
veris(operator.lt(0, 0), False) self.assertIs(unicode("0123", 'ascii').isdigit(), True)
veris(operator.lt(0, 1), True) self.assertIs(unicode("xyz", 'ascii').isdigit(), False)
self.assertIs(unicode("xyz", 'ascii').islower(), True)
import marshal self.assertIs(unicode("XYZ", 'ascii').islower(), False)
veris(marshal.loads(marshal.dumps(True)), True) self.assertIs(unicode("0123", 'ascii').isnumeric(), True)
veris(marshal.loads(marshal.dumps(False)), False) self.assertIs(unicode("xyz", 'ascii').isnumeric(), False)
self.assertIs(unicode(" ", 'ascii').isspace(), True)
import pickle self.assertIs(unicode("XYZ", 'ascii').isspace(), False)
veris(pickle.loads(pickle.dumps(True)), True) self.assertIs(unicode("X", 'ascii').istitle(), True)
veris(pickle.loads(pickle.dumps(False)), False) self.assertIs(unicode("x", 'ascii').istitle(), False)
veris(pickle.loads(pickle.dumps(True, True)), True) self.assertIs(unicode("XYZ", 'ascii').isupper(), True)
veris(pickle.loads(pickle.dumps(False, True)), False) self.assertIs(unicode("xyz", 'ascii').isupper(), False)
self.assertIs(unicode("xyz", 'ascii').startswith(unicode("x", 'ascii')), True)
import cPickle self.assertIs(unicode("xyz", 'ascii').startswith(unicode("z", 'ascii')), False)
veris(cPickle.loads(cPickle.dumps(True)), True)
veris(cPickle.loads(cPickle.dumps(False)), False) def test_boolean(self):
veris(cPickle.loads(cPickle.dumps(True, True)), True) self.assertEqual(True & 1, 1)
veris(cPickle.loads(cPickle.dumps(False, True)), False) self.assert_(not isinstance(True & 1, bool))
self.assertIs(True & True, True)
veris(pickle.loads(cPickle.dumps(True)), True)
veris(pickle.loads(cPickle.dumps(False)), False) self.assertEqual(True | 1, 1)
veris(pickle.loads(cPickle.dumps(True, True)), True) self.assert_(not isinstance(True | 1, bool))
veris(pickle.loads(cPickle.dumps(False, True)), False) self.assertIs(True | True, True)
veris(cPickle.loads(pickle.dumps(True)), True) self.assertEqual(True ^ 1, 0)
veris(cPickle.loads(pickle.dumps(False)), False) self.assert_(not isinstance(True ^ 1, bool))
veris(cPickle.loads(pickle.dumps(True, True)), True) self.assertIs(True ^ True, False)
veris(cPickle.loads(pickle.dumps(False, True)), False)
def test_fileclosed(self):
# Test for specific backwards-compatible pickle values try:
vereq(pickle.dumps(True), "I01\n.") f = file(TESTFN, "w")
vereq(pickle.dumps(False), "I00\n.") self.assertIs(f.closed, False)
vereq(cPickle.dumps(True), "I01\n.") f.close()
vereq(cPickle.dumps(False), "I00\n.") self.assertIs(f.closed, True)
vereq(pickle.dumps(True, True), "I01\n.") finally:
vereq(pickle.dumps(False, True), "I00\n.") os.remove(TESTFN)
vereq(cPickle.dumps(True, True), "I01\n.")
vereq(cPickle.dumps(False, True), "I00\n.") def test_operator(self):
import operator
if verbose: self.assertIs(operator.truth(0), False)
print "All OK" self.assertIs(operator.truth(1), True)
self.assertIs(operator.isCallable(0), False)
self.assertIs(operator.isCallable(len), True)
self.assertIs(operator.isNumberType(None), False)
self.assertIs(operator.isNumberType(0), True)
self.assertIs(operator.not_(1), False)
self.assertIs(operator.not_(0), True)
self.assertIs(operator.isSequenceType(0), False)
self.assertIs(operator.isSequenceType([]), True)
self.assertIs(operator.contains([], 1), False)
self.assertIs(operator.contains([1], 1), True)
self.assertIs(operator.isMappingType(1), False)
self.assertIs(operator.isMappingType({}), True)
self.assertIs(operator.lt(0, 0), False)
self.assertIs(operator.lt(0, 1), True)
self.assertIs(operator.is_(True, True), True)
self.assertIs(operator.is_(True, False), False)
self.assertIs(operator.is_not(True, True), False)
self.assertIs(operator.is_not(True, False), True)
def test_marshal(self):
import marshal
veris(marshal.loads(marshal.dumps(True)), True)
veris(marshal.loads(marshal.dumps(False)), False)
def test_pickle(self):
import pickle
self.assertIs(pickle.loads(pickle.dumps(True)), True)
self.assertIs(pickle.loads(pickle.dumps(False)), False)
self.assertIs(pickle.loads(pickle.dumps(True, True)), True)
self.assertIs(pickle.loads(pickle.dumps(False, True)), False)
def test_cpickle(self):
import cPickle
self.assertIs(cPickle.loads(cPickle.dumps(True)), True)
self.assertIs(cPickle.loads(cPickle.dumps(False)), False)
self.assertIs(cPickle.loads(cPickle.dumps(True, True)), True)
self.assertIs(cPickle.loads(cPickle.dumps(False, True)), False)
def test_mixedpickle(self):
import pickle, cPickle
self.assertIs(pickle.loads(cPickle.dumps(True)), True)
self.assertIs(pickle.loads(cPickle.dumps(False)), False)
self.assertIs(pickle.loads(cPickle.dumps(True, True)), True)
self.assertIs(pickle.loads(cPickle.dumps(False, True)), False)
self.assertIs(cPickle.loads(pickle.dumps(True)), True)
self.assertIs(cPickle.loads(pickle.dumps(False)), False)
self.assertIs(cPickle.loads(pickle.dumps(True, True)), True)
self.assertIs(cPickle.loads(pickle.dumps(False, True)), False)
def test_picklevalues(self):
import pickle, cPickle
# Test for specific backwards-compatible pickle values
self.assertEqual(pickle.dumps(True), "I01\n.")
self.assertEqual(pickle.dumps(False), "I00\n.")
self.assertEqual(cPickle.dumps(True), "I01\n.")
self.assertEqual(cPickle.dumps(False), "I00\n.")
self.assertEqual(pickle.dumps(True, True), "I01\n.")
self.assertEqual(pickle.dumps(False, True), "I00\n.")
self.assertEqual(cPickle.dumps(True, True), "I01\n.")
self.assertEqual(cPickle.dumps(False, True), "I00\n.")
def test_main():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(BoolTest))
test_support.run_suite(suite)
if __name__ == "__main__":
test_main()
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment