10a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# Python test set -- built-in functions 20a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport platform 40a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport unittest 50a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom test.test_support import fcmp, have_unicode, TESTFN, unlink, \ 60a8c90248264a8b26970b4473770bcc3df8515fJosh Gao run_unittest, check_py3k_warnings 70a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport warnings 80a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom operator import neg 90a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 100a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport sys, cStringIO, random, UserDict 110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# count the number of test runs. 130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# used to skip running test_execfile() multiple times 140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# and to create unique strings to intern in test_intern() 150a8c90248264a8b26970b4473770bcc3df8515fJosh Gaonumruns = 0 160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 170a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass Squares: 180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, max): 200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.max = max 210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.sofar = [] 220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __len__(self): return len(self.sofar) 240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, i): 260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not 0 <= i < self.max: raise IndexError 270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = len(self.sofar) 280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while n <= i: 290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.sofar.append(n*n) 300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n += 1 310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self.sofar[i] 320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 330a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass StrSquares: 340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, max): 360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.max = max 370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.sofar = [] 380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __len__(self): 400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return len(self.sofar) 410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, i): 430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not 0 <= i < self.max: 440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IndexError 450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = len(self.sofar) 460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while n <= i: 470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.sofar.append(str(n*n)) 480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n += 1 490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self.sofar[i] 500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 510a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass BitBucket: 520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def write(self, line): 530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 560a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass TestFailingBool: 570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __nonzero__(self): 580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise RuntimeError 590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 600a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass TestFailingIter: 610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __iter__(self): 620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise RuntimeError 630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 640a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass BuiltinTest(unittest.TestCase): 650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_import(self): 670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __import__('sys') 680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __import__('time') 690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __import__('string') 700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __import__(name='sys') 710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __import__(name='time', level=0) 720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ImportError, __import__, 'spamspam') 730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, __import__, 1, 2, 3, 4) 740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, __import__, '') 750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, __import__, 'sys', name='sys') 760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_abs(self): 780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # int 790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(0), 0) 800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(1234), 1234) 810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(-1234), 1234) 820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(abs(-sys.maxint-1) > 0) 830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # float 840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(0.0), 0.0) 850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(3.14), 3.14) 860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(-3.14), 3.14) 870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # long 880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(0L), 0L) 890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(1234L), 1234L) 900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(-1234L), 1234L) 910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # str 920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, abs, 'a') 930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # bool 940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(True), 1) 950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(False), 0) 960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # other 970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, abs) 980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, abs, None) 990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class AbsClass(object): 1000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __abs__(self): 1010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return -5 1020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(abs(AbsClass()), -5) 1030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_all(self): 1050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(all([2, 4, 6]), True) 1060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(all([2, None, 6]), False) 1070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6]) 1080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, all, TestFailingIter()) 1090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, all, 10) # Non-iterable 1100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, all) # No args 1110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args 1120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(all([]), True) # Empty iterator 1130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit 1140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao S = [50, 60] 1150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(all(x > 42 for x in S), True) 1160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao S = [50, 40, 60] 1170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(all(x > 42 for x in S), False) 1180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_any(self): 1200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(any([None, None, None]), False) 1210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(any([None, 4, None]), True) 1220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6]) 1230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, any, TestFailingIter()) 1240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, any, 10) # Non-iterable 1250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, any) # No args 1260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args 1270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(any([]), False) # Empty iterator 1280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit 1290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao S = [40, 60, 30] 1300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(any(x > 42 for x in S), True) 1310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao S = [10, 20, 30] 1320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(any(x > 42 for x in S), False) 1330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_neg(self): 1350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao x = -sys.maxint-1 1360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(isinstance(x, int)) 1370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(-x, sys.maxint+1) 1380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_apply(self): 1400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f0(*args): 1410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(args, ()) 1420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f1(a1): 1430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(a1, 1) 1440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f2(a1, a2): 1450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(a1, 1) 1460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(a2, 2) 1470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f3(a1, a2, a3): 1480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(a1, 1) 1490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(a2, 2) 1500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(a3, 3) 1510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao apply(f0, ()) 1520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao apply(f1, (1,)) 1530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao apply(f2, (1, 2)) 1540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao apply(f3, (1, 2, 3)) 1550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # A PyCFunction that takes only positional parameters should allow an 1570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # empty keyword dictionary to pass without a complaint, but raise a 1580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # TypeError if the dictionary is non-empty. 1590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao apply(id, (1,), {}) 1600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, apply, id, (1,), {"foo": 1}) 1610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, apply) 1620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, apply, id, 42) 1630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, apply, id, (42,), 42) 1640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_callable(self): 1660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(len)) 1670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable("a")) 1680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(callable)) 1690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(lambda x, y: x + y)) 1700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable(__builtins__)) 1710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f(): pass 1720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(f)) 1730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Classic: 1750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def meth(self): pass 1760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(Classic)) 1770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = Classic() 1780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(c.meth)) 1790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable(c)) 1800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class NewStyle(object): 1820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def meth(self): pass 1830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(NewStyle)) 1840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = NewStyle() 1850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(n.meth)) 1860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable(n)) 1870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Classic and new-style classes evaluate __call__() differently 1890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c.__call__ = None 1900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(c)) 1910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del c.__call__ 1920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable(c)) 1930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n.__call__ = None 1940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable(n)) 1950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del n.__call__ 1960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(callable(n)) 1970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class N2(object): 1990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __call__(self): pass 2000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n2 = N2() 2010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(n2)) 2020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class N3(N2): pass 2030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n3 = N3() 2040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(callable(n3)) 2050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_chr(self): 2070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(chr(32), ' ') 2080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(chr(65), 'A') 2090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(chr(97), 'a') 2100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(chr(0xff), '\xff') 2110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, chr, 256) 2120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, chr) 2130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_cmp(self): 2150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(cmp(-1, 1), -1) 2160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(cmp(1, -1), 1) 2170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(cmp(1, 1), 0) 2180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # verify that circular objects are not handled 2190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = []; a.append(a) 2200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = []; b.append(b) 2210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao from UserList import UserList 2220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = UserList(); c.append(c) 2230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, cmp, a, b) 2240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, cmp, b, c) 2250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, cmp, c, a) 2260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, cmp, a, c) 2270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # okay, now break the cycles 2280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a.pop(); b.pop(); c.pop() 2290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, cmp) 2300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_coerce(self): 2320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) 2330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(coerce(1, 1L), (1L, 1L)) 2340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1))) 2350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, coerce) 2360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadNumber: 2370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __coerce__(self, other): 2380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 2390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, coerce, 42, BadNumber()) 2400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000)) 2410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_compile(self): 2430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao compile('print 1\n', '', 'exec') 2440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bom = '\xef\xbb\xbf' 2450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao compile(bom + 'print 1\n', '', 'exec') 2460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao compile(source='pass', filename='?', mode='exec') 2470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao compile(dont_inherit=0, filename='tmp', source='0', mode='eval') 2480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao compile('pass', '?', dont_inherit=1, mode='exec') 2490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, compile) 2500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode') 2510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff) 2520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') 2530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, compile, 'pass', '?', 'exec', 2540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao mode='eval', source='0', filename='tmp') 2550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 2560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec') 2570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec') 2580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad') 2590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_delattr(self): 2620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import sys 2630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.spam = 1 2640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao delattr(sys, 'spam') 2650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, delattr) 2660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_dir(self): 2680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(wrong number of arguments) 2690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, dir, 42, 42) 2700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir() - local scope 2720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao local_var = 1 2730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn('local_var', dir()) 2740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(module) 2760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import sys 2770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn('exit', dir(sys)) 2780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(module_with_invalid__dict__) 2800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import types 2810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Foo(types.ModuleType): 2820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __dict__ = 8 2830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = Foo("foo") 2840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, dir, f) 2850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(type) 2870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn("strip", dir(str)) 2880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIn("__mro__", dir(str)) 2890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(obj) 2910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Foo(object): 2920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self): 2930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.x = 7 2940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.y = 8 2950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.z = 9 2960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = Foo() 2970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn("y", dir(f)) 2980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(obj_no__dict__) 3000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Foo(object): 3010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __slots__ = [] 3020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = Foo() 3030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn("__repr__", dir(f)) 3040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(obj_no__class__with__dict__) 3060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (an ugly trick to cause getattr(f, "__class__") to fail) 3070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Foo(object): 3080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __slots__ = ["__class__", "__dict__"] 3090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self): 3100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.bar = "wow" 3110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = Foo() 3120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIn("__repr__", dir(f)) 3130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn("bar", dir(f)) 3140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(obj_using __dir__) 3160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Foo(object): 3170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __dir__(self): 3180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return ["kan", "ga", "roo"] 3190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = Foo() 3200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(dir(f) == ["ga", "kan", "roo"]) 3210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # dir(obj__dir__not_list) 3230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Foo(object): 3240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __dir__(self): 3250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 7 3260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = Foo() 3270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, dir, f) 3280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_divmod(self): 3300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(12, 7), (1, 5)) 3310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-12, 7), (-2, 2)) 3320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(12, -7), (-2, -2)) 3330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-12, -7), (1, -5)) 3340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(12L, 7L), (1L, 5L)) 3360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-12L, 7L), (-2L, 2L)) 3370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(12L, -7L), (-2L, -2L)) 3380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-12L, -7L), (1L, -5L)) 3390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(12, 7L), (1, 5L)) 3410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-12, 7L), (-2, 2L)) 3420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(12L, -7), (-2L, -2)) 3430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-12L, -7), (1L, -5)) 3440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(divmod(-sys.maxint-1, -1), 3460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (sys.maxint+1, 0)) 3470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) 3490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) 3500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) 3510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) 3520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, divmod) 3540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_eval(self): 3560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('1+1'), 2) 3570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(' 1+1\n'), 2) 3580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao globals = {'a': 1, 'b': 2} 3590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao locals = {'b': 200, 'c': 300} 3600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('a', globals) , 1) 3610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('a', globals, locals), 1) 3620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('b', globals, locals), 200) 3630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('c', globals, locals), 300) 3640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 3650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode('1+1')), 2) 3660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode(' 1+1\n')), 2) 3670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao globals = {'a': 1, 'b': 2} 3680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao locals = {'b': 200, 'c': 300} 3690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 3700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode('a'), globals), 1) 3710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode('a'), globals, locals), 1) 3720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode('b'), globals, locals), 200) 3730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode('c'), globals, locals), 300) 3740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bom = '\xef\xbb\xbf' 3750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(bom + 'a', globals, locals), 1) 3760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals), 3770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unicode('\xc3\xa5', 'utf8')) 3780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, eval) 3790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, eval, ()) 3800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_general_eval(self): 3820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Tests that general mappings can be used for the locals argument 3830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class M: 3850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "Test mapping interface versus possible calls from eval()." 3860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, key): 3870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if key == 'a': 3880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 12 3890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise KeyError 3900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def keys(self): 3910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return list('xyz') 3920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao m = M() 3940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao g = globals() 3950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('a', g, m), 12) 3960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(NameError, eval, 'b', g, m) 3970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('dir()', g, m), list('xyz')) 3980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('globals()', g, m), g) 3990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('locals()', g, m), m) 4000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, eval, 'a', m) 4010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class A: 4020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "Non-mapping" 4030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 4040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao m = A() 4050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, eval, 'a', g, m) 4060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Verify that dict subclasses work as well 4080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class D(dict): 4090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, key): 4100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if key == 'a': 4110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 12 4120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return dict.__getitem__(self, key) 4130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def keys(self): 4140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return list('xyz') 4150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao d = D() 4170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('a', g, d), 12) 4180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(NameError, eval, 'b', g, d) 4190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('dir()', g, d), list('xyz')) 4200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('globals()', g, d), g) 4210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(eval('locals()', g, d), d) 4220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Verify locals stores (used by list comps) 4240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao eval('[locals() for i in (2,3)]', g, d) 4250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao eval('[locals() for i in (2,3)]', g, UserDict.UserDict()) 4260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class SpreadSheet: 4280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "Sample application showing nested, calculated lookups." 4290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _cells = {} 4300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __setitem__(self, key, formula): 4310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._cells[key] = formula 4320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, key): 4330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return eval(self._cells[key], globals(), self) 4340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ss = SpreadSheet() 4360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ss['a1'] = '5' 4370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ss['a2'] = 'a1*6' 4380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ss['a3'] = 'a2*7' 4390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(ss['a3'], 210) 4400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Verify that dir() catches a non-list returned by eval 4420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # SF bug #1004669 4430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class C: 4440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, item): 4450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise KeyError(item) 4460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def keys(self): 4470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 'a' 4480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, eval, 'dir()', globals(), C()) 4490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Done outside of the method test_z to get the correct scope 4510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao z = 0 4520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = open(TESTFN, 'w') 4530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('z = z+1\n') 4540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('z = z*2\n') 4550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 4560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with check_py3k_warnings(("execfile.. not supported in 3.x", 4570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao DeprecationWarning)): 4580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao execfile(TESTFN) 4590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_execfile(self): 4610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao global numruns 4620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if numruns: 4630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 4640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao numruns += 1 4650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao globals = {'a': 1, 'b': 2} 4670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao locals = {'b': 200, 'c': 300} 4680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(self.__class__.z, 2) 4700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao globals['z'] = 0 4710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao execfile(TESTFN, globals) 4720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(globals['z'], 2) 4730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao locals['z'] = 0 4740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao execfile(TESTFN, globals, locals) 4750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(locals['z'], 2) 4760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class M: 4780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "Test mapping interface versus possible calls from execfile()." 4790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self): 4800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.z = 10 4810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, key): 4820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if key == 'z': 4830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self.z 4840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise KeyError 4850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __setitem__(self, key, value): 4860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if key == 'z': 4870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.z = value 4880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 4890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise KeyError 4900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao locals = M() 4920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao locals['z'] = 0 4930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao execfile(TESTFN, globals, locals) 4940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(locals['z'], 2) 4950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unlink(TESTFN) 4970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, execfile) 4980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, execfile, TESTFN, {}, ()) 4990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import os 5000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, execfile, os.curdir) 5010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, execfile, "I_dont_exist") 5020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_filter(self): 5040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld') 5050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9]) 5060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2]) 5070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81]) 5080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81]) 5090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def identity(item): 5100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 1 5110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filter(identity, Squares(5)) 5120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter) 5130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq(object): 5140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if index<4: 5160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 42 5170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 5180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, filter, lambda x: x, BadSeq()) 5190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def badfunc(): 5200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 5210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter, badfunc, range(5)) 5220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test bltinmodule.c::filtertuple() 5240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(None, (1, 2)), (1, 2)) 5250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4)) 5260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter, 42, (1, 2)) 5270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test bltinmodule.c::filterstring() 5290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(None, "12"), "12") 5300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x>="3", "1234"), "34") 5310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter, 42, "12") 5320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class badstr(str): 5330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 5350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234")) 5360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class badstr2(str): 5380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 42 5400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234")) 5410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class weirdstr(str): 5430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return weirdstr(2*str.__getitem__(self, index)) 5450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344") 5460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class shiftstr(str): 5480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return chr(ord(str.__getitem__(self, index))+1) 5500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345") 5510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 5530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test bltinmodule.c::filterunicode() 5540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(None, unicode("12")), unicode("12")) 5550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34")) 5560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter, 42, unicode("12")) 5570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234"))) 5580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class badunicode(unicode): 5600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 42 5620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234")) 5630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class weirdunicode(unicode): 5650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return weirdunicode(2*unicode.__getitem__(self, index)) 5670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 5680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344")) 5690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class shiftunicode(unicode): 5710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return unichr(ord(unicode.__getitem__(self, index))+1) 5730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 5740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filter(lambda x: x>=unicode("3"), shiftunicode("1234")), 5750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unicode("345") 5760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 5770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_filter_subclasses(self): 5790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test that filter() never returns tuple, str or unicode subclasses 5800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # and that the result always goes through __getitem__ 5810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao funcs = (None, bool, lambda x: True) 5820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class tuple2(tuple): 5830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 2*tuple.__getitem__(self, index) 5850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class str2(str): 5860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 2*str.__getitem__(self, index) 5880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao inputs = { 5890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tuple2: {(): (), (1, 2, 3): (2, 4, 6)}, 5900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao str2: {"": "", "123": "112233"} 5910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao } 5920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 5930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class unicode2(unicode): 5940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 5950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 2*unicode.__getitem__(self, index) 5960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao inputs[unicode2] = { 5970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unicode(): unicode(), 5980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unicode("123"): unicode("112233") 5990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao } 6000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for (cls, inps) in inputs.iteritems(): 6020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for (inp, exp) in inps.iteritems(): 6030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # make sure the output goes through __getitem__ 6040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # even if func is None 6050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 6060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filter(funcs[0], cls(inp)), 6070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filter(funcs[1], cls(inp)) 6080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 6090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for func in funcs: 6100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao outp = filter(func, cls(inp)) 6110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(outp, exp) 6120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not isinstance(outp, cls)) 6130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_getattr(self): 6150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import sys 6160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(getattr(sys, 'stdout') is sys.stdout) 6170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, getattr, sys, 1) 6180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, getattr, sys, 1, "foo") 6190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, getattr) 6200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 6210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode)) 6220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_hasattr(self): 6240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import sys 6250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(hasattr(sys, 'stdout')) 6260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, hasattr, sys, 1) 6270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, hasattr) 6280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 6290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode)) 6300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Check that hasattr allows SystemExit and KeyboardInterrupts by 6320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class A: 6330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getattr__(self, what): 6340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise KeyboardInterrupt 6350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") 6360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class B: 6370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getattr__(self, what): 6380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise SystemExit 6390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(SystemExit, hasattr, B(), "b") 6400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_hash(self): 6420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao hash(None) 6430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hash(1), hash(1L)) 6440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hash(1), hash(1.0)) 6450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao hash('spam') 6460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 6470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hash('spam'), hash(unicode('spam'))) 6480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao hash((0,1,2,3)) 6490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f(): pass 6500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, hash, []) 6510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, hash, {}) 6520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Bug 1536021: Allow hash to return long objects 6530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class X: 6540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __hash__(self): 6550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 2**100 6560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(hash(X())), int) 6570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Y(object): 6580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __hash__(self): 6590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 2**100 6600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(hash(Y())), int) 6610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Z(long): 6620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __hash__(self): 6630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self 6640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hash(Z(42)), hash(42L)) 6650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_hex(self): 6670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hex(16), '0x10') 6680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hex(16L), '0x10L') 6690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hex(-16), '-0x10') 6700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(hex(-16L), '-0x10L') 6710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, hex, {}) 6720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_id(self): 6740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id(None) 6750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id(1) 6760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id(1L) 6770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id(1.0) 6780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id('spam') 6790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id((0,1,2,3)) 6800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id([0,1,2,3]) 6810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao id({'spam': 1, 'eggs': 2, 'ham': 3}) 6820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test input() later, together with raw_input 6840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test_int(): see test_int.py for int() tests. 6860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_intern(self): 6880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, intern) 6890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This fails if the test is run twice with a constant string, 6900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # therefore append the run counter 6910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = "never interned before " + str(numruns) 6920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(intern(s) is s) 6930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s2 = s.swapcase().swapcase() 6940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(intern(s2) is s) 6950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Subclasses of string can't be interned, because they 6970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # provide too much opportunity for insane things to happen. 6980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We don't want them in the interned dict and if they aren't 6990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # actually interned, we don't want to create the appearance 7000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # that they are by allowing intern() to succeed. 7010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class S(str): 7020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __hash__(self): 7030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 123 7040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, intern, S("abc")) 7060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # It's still safe to pass these strings to routines that 7080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # call intern internally, e.g. PyObject_SetAttr(). 7090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = S("abc") 7100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao setattr(s, s, s) 7110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(getattr(s, s), s) 7120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_iter(self): 7140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, iter) 7150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, iter, 42, 42) 7160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao lists = [("1", "2"), ["1", "2"], "12"] 7170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 7180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao lists.append(unicode("12")) 7190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for l in lists: 7200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao i = iter(l) 7210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(i.next(), '1') 7220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(i.next(), '2') 7230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(StopIteration, i.next) 7240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_isinstance(self): 7260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class C: 7270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class D(C): 7290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class E: 7310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = C() 7330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao d = D() 7340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao e = E() 7350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(isinstance(c, C)) 7360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(isinstance(d, C)) 7370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not isinstance(e, C)) 7380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not isinstance(c, D)) 7390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not isinstance('foo', E)) 7400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, isinstance, E, 'foo') 7410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, isinstance) 7420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issubclass(self): 7440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class C: 7450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class D(C): 7470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class E: 7490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = C() 7510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao d = D() 7520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao e = E() 7530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(issubclass(D, C)) 7540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(issubclass(C, C)) 7550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(not issubclass(C, D)) 7560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, issubclass, 'foo', E) 7570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, issubclass, E, 'foo') 7580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, issubclass) 7590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_len(self): 7610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len('123'), 3) 7620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(()), 0) 7630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len((1, 2, 3, 4)), 4) 7640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len([1, 2, 3, 4]), 4) 7650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len({}), 0) 7660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len({'a':1, 'b': 2}), 2) 7670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq: 7680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __len__(self): 7690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 7700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, len, BadSeq()) 7710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, len, 2) 7720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class ClassicStyle: pass 7730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class NewStyle(object): pass 7740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(AttributeError, len, ClassicStyle()) 7750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, len, NewStyle()) 7760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_map(self): 7780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 7790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(None, 'hello world'), 7800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ['h','e','l','l','o',' ','w','o','r','l','d'] 7810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 7820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 7830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(None, 'abcd', 'efg'), 7840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)] 7850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 7860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 7870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(None, range(10)), 7880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 7890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 7900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 7910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(lambda x: x*x, range(1,4)), 7920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [1, 4, 9] 7930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 7940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 7950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao from math import sqrt 7960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except ImportError: 7970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def sqrt(x): 7980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return pow(x, 0.5) 7990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]), 8010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [[4.0, 2.0], [9.0, 3.0]] 8020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(lambda x, y: x+y, [1,3,2], [9,1,4]), 8050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [10, 4, 6] 8060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def plus(*v): 8090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao accu = 0 8100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in v: accu = accu + i 8110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return accu 8120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(plus, [1, 3, 7]), 8140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [1, 3, 7] 8150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(plus, [1, 3, 7], [4, 9, 2]), 8180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [1+4, 3+9, 7+2] 8190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]), 8220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [1+4+1, 3+9+1, 7+2+0] 8230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(None, Squares(10)), 8260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 8270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(int, Squares(10)), 8300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 8310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(None, Squares(3), Squares(2)), 8340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [(0,0), (1,1), (4,None)] 8350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 8370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao map(max, Squares(3), Squares(2)), 8380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [0, 1, 4] 8390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 8400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, map) 8410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, map, lambda x: x, 42) 8420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(map(None, [42]), [42]) 8430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq: 8440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 8450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 8460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, map, lambda x: x, BadSeq()) 8470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def badfunc(x): 8480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise RuntimeError 8490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, map, badfunc, range(5)) 8500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_max(self): 8520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max('123123'), '3') 8530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max(1, 2, 3), 3) 8540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3) 8550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3) 8560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max(1, 2L, 3.0), 3.0) 8580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max(1L, 2.0, 3), 3) 8590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max(1.0, 2, 3L), 3L) 8600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for stmt in ( 8620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "max(key=int)", # no args 8630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "max(1, key=int)", # single arg not iterable 8640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "max(1, 2, keystone=int)", # wrong keyword 8650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "max(1, 2, key=int, abc=int)", # two many keywords 8660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "max(1, 2, key=1)", # keyfunc is not callable 8670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ): 8680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 8690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao exec(stmt) in globals() 8700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except TypeError: 8710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 8720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 8730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.fail(stmt) 8740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max((1,), key=neg), 1) # one elem iterable 8760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max((1,2), key=neg), 1) # two elem iterable 8770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max(1, 2, key=neg), 1) # two elems 8780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = [random.randrange(200) for i in range(100)] 8800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao keys = dict((elem, random.randrange(50)) for elem in data) 8810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = keys.__getitem__ 8820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(max(data, key=f), 8830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sorted(reversed(data), key=f)[-1]) 8840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_min(self): 8860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min('123123'), '1') 8870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min(1, 2, 3), 1) 8880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1) 8890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1) 8900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min(1, 2L, 3.0), 1) 8920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min(1L, 2.0, 3), 1L) 8930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min(1.0, 2, 3L), 1.0) 8940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, min) 8960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, min, 42) 8970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, min, ()) 8980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq: 8990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 9000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 9010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, min, BadSeq()) 9020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadNumber: 9030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __cmp__(self, other): 9040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 9050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, min, (42, BadNumber())) 9060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for stmt in ( 9080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "min(key=int)", # no args 9090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "min(1, key=int)", # single arg not iterable 9100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "min(1, 2, keystone=int)", # wrong keyword 9110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "min(1, 2, key=int, abc=int)", # two many keywords 9120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "min(1, 2, key=1)", # keyfunc is not callable 9130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ): 9140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 9150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao exec(stmt) in globals() 9160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except TypeError: 9170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 9180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 9190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.fail(stmt) 9200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min((1,), key=neg), 1) # one elem iterable 9220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min((1,2), key=neg), 2) # two elem iterable 9230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min(1, 2, key=neg), 2) # two elems 9240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = [random.randrange(200) for i in range(100)] 9260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao keys = dict((elem, random.randrange(50)) for elem in data) 9270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = keys.__getitem__ 9280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(min(data, key=f), 9290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sorted(data, key=f)[0]) 9300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_next(self): 9320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao it = iter(range(2)) 9330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(next(it), 0) 9340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(next(it), 1) 9350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(StopIteration, next, it) 9360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(StopIteration, next, it) 9370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(next(it, 42), 42) 9380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Iter(object): 9400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __iter__(self): 9410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self 9420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def next(self): 9430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise StopIteration 9440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao it = iter(Iter()) 9460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(next(it, 42), 42) 9470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(StopIteration, next, it) 9480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def gen(): 9500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao yield 1 9510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 9520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao it = gen() 9540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(next(it), 1) 9550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(StopIteration, next, it) 9560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(next(it, 42), 42) 9570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_oct(self): 9590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(oct(100), '0144') 9600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(oct(100L), '0144L') 9610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(oct(-100), '-0144') 9620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(oct(-100L), '-0144L') 9630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, oct, ()) 9640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def write_testfile(self): 9660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # NB the first 4 lines are also used to test input and raw_input, below 9670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp = open(TESTFN, 'w') 9680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 9690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('1+1\n') 9700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('1+1\n') 9710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('The quick brown fox jumps over the lazy dog') 9720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('.\n') 9730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('Dear John\n') 9740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('XXX'*100) 9750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.write('YYY'*100) 9760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 9770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.close() 9780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_open(self): 9800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.write_testfile() 9810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp = open(TESTFN, 'r') 9820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 9830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.readline(4), '1+1\n') 9840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.readline(4), '1+1\n') 9850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n') 9860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.readline(4), 'Dear') 9870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.readline(100), ' John\n') 9880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.read(300), 'XXX'*100) 9890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(fp.read(1000), 'YYY'*100) 9900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 9910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.close() 9920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unlink(TESTFN) 9930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_ord(self): 9950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(ord(' '), 32) 9960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(ord('A'), 65) 9970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(ord('a'), 97) 9980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 9990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode) 10000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, ord, 42) 10010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 10020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, ord, unicode("12")) 10030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_pow(self): 10050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(0,0), 1) 10060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(0,1), 0) 10070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(1,0), 1) 10080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(1,1), 1) 10090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2,0), 1) 10110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2,10), 1024) 10120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2,20), 1024*1024) 10130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2,30), 1024*1024*1024) 10140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2,0), 1) 10160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2,1), -2) 10170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2,2), 4) 10180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2,3), -8) 10190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(0L,0), 1) 10210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(0L,1), 0) 10220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(1L,0), 1) 10230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(1L,1), 1) 10240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2L,0), 1) 10260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2L,10), 1024) 10270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2L,20), 1024*1024) 10280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(2L,30), 1024*1024*1024) 10290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2L,0), 1) 10310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2L,1), -2) 10320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2L,2), 4) 10330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pow(-2L,3), -8) 10340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(0.,0), 1.) 10360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(0.,1), 0.) 10370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(1.,0), 1.) 10380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(1.,1), 1.) 10390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(2.,0), 1.) 10410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(2.,10), 1024.) 10420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(2.,20), 1024.*1024.) 10430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.) 10440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(-2.,0), 1.) 10460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(-2.,1), -2.) 10470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(-2.,2), 4.) 10480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(-2.,3), -8.) 10490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for x in 2, 2L, 2.0: 10510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for y in 10, 10L, 10.0: 10520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for z in 1000, 1000L, 1000.0: 10530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if isinstance(x, float) or \ 10540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao isinstance(y, float) or \ 10550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao isinstance(z, float): 10560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, pow, x, y, z) 10570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 10580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertAlmostEqual(pow(x, y, z), 24.0) 10590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, pow, -1, -2, 3) 10610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, pow, 1, 2, 0) 10620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, pow, -1L, -2L, 3L) 10630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, pow, 1L, 2L, 0L) 10640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Will return complex in 3.0: 10650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, pow, -342.43, 0.234) 10660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, pow) 10680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_range(self): 10700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(3), [0, 1, 2]) 10710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(1, 5), [1, 2, 3, 4]) 10720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(0), []) 10730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(-3), []) 10740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(1, 10, 3), [1, 4, 7]) 10750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(5, -5, -3), [5, 2, -1, -4]) 10760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Now test range() with longs 10780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(-2**100), []) 10790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(0, -2**100), []) 10800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(0, 2**100, -1), []) 10810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(0, 2**100, -1), []) 10820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = long(10 * sys.maxint) 10840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = long(100 * sys.maxint) 10850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = long(50 * sys.maxint) 10860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(a, a+2), [a, a+1]) 10880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(a+2, a, -1L), [a+2, a+1]) 10890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(a+4, a, -2), [a+4, a+2]) 10900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao seq = range(a, b, c) 10920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn(a, seq) 10930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIn(b, seq) 10940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(seq), 2) 10950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao seq = range(b, a, -c) 10970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn(b, seq) 10980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIn(a, seq) 10990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(seq), 2) 11000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao seq = range(-a, -b, -c) 11020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn(-a, seq) 11030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIn(-b, seq) 11040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(seq), 2) 11050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range) 11070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 1, 2, 3, 4) 11080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, range, 1, 2, 0) 11090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, range, a, a + 1, long(0)) 11100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class badzero(int): 11120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __cmp__(self, other): 11130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise RuntimeError 11140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __hash__ = None # Invalid cmp makes this unhashable 11150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) 11160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Reject floats. 11180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 1., 1., 1.) 11190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) 11200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0, "spam") 11220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0, 42, "spam") 11230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) 11250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(OverflowError, range, 0, 2*sys.maxint) 11260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bignum = 2*sys.maxint 11280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao smallnum = 42 11290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Old-style user-defined class with __int__ method 11300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class I0: 11310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, n): 11320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.n = int(n) 11330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __int__(self): 11340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self.n 11350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) 11360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) 11370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # New-style user-defined class with __int__ method 11390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class I1(object): 11400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, n): 11410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.n = int(n) 11420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __int__(self): 11430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self.n 11440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) 11450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) 11460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # New-style user-defined class with failing __int__ method 11480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class IX(object): 11490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __int__(self): 11500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise RuntimeError 11510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, range, IX()) 11520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # New-style user-defined class with invalid __int__ method 11540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class IN(object): 11550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __int__(self): 11560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return "not a number" 11570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, IN()) 11580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Exercise various combinations of bad arguments, to check 11600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # refcounting logic 11610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0) 11620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0, 0.0) 11640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0, 0) 11650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0, 0.0) 11660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0, 0, 1.0) 11680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0, 0.0, 1) 11690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0, 0.0, 1.0) 11700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0, 0, 1) 11710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0, 0, 1.0) 11720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0, 0.0, 1) 11730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) 11740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_input_and_raw_input(self): 11780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.write_testfile() 11790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp = open(TESTFN, 'r') 11800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao savestdin = sys.stdin 11810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao savestdout = sys.stdout # Eats the echo 11820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 11830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin = fp 11840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdout = BitBucket() 11850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(input(), 2) 11860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(input('testing\n'), 2) 11870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.') 11880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw_input('testing\n'), 'Dear John') 11890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # SF 1535165: don't segfault on closed stdin 11910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # sys.stdout must be a regular file for triggering 11920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdout = savestdout 11930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin.close() 11940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, input) 11950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdout = BitBucket() 11970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin = cStringIO.StringIO("NULL\0") 11980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, input, 42, 42) 11990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin = cStringIO.StringIO(" 'whitespace'") 12000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(input(), 'whitespace') 12010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin = cStringIO.StringIO() 12020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(EOFError, input) 12030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # SF 876178: make sure input() respect future options. 12050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin = cStringIO.StringIO('1/2') 12060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdout = cStringIO.StringIO() 12070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao exec compile('print input()', 'test_builtin_tmp', 'exec') 12080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin.seek(0, 0) 12090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao exec compile('from __future__ import division;print input()', 12100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'test_builtin_tmp', 'exec') 12110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin.seek(0, 0) 12120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao exec compile('print input()', 'test_builtin_tmp', 'exec') 12130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The result we expect depends on whether new division semantics 12140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # are already in effect. 12150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if 1/2 == 0: 12160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This test was compiled with old semantics. 12170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao expected = ['0', '0.5', '0'] 12180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 12190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This test was compiled with new semantics (e.g., -Qnew 12200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # was given on the command line. 12210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao expected = ['0.5', '0.5', '0.5'] 12220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sys.stdout.getvalue().splitlines(), expected) 12230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del sys.stdout 12250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, input, 'prompt') 12260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del sys.stdin 12270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(RuntimeError, input, 'prompt') 12280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 12290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdin = savestdin 12300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sys.stdout = savestdout 12310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fp.close() 12320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unlink(TESTFN) 12330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_reduce(self): 12350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao add = lambda x, y: x+y 12360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') 12370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 12380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reduce(add, [['a', 'c'], [], ['d', 'w']], []), 12390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ['a','c','d','w'] 12400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 12410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040) 12420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 12430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reduce(lambda x, y: x*y, range(2,21), 1L), 12440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2432902008176640000L 12450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 12460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(add, Squares(10)), 285) 12470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(add, Squares(10), 0), 285) 12480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(add, Squares(0), 0), 0) 12490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce) 12500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, 42) 12510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, 42, 42) 12520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, 42, 42, 42) 12530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, None, range(5)) 12540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, add, 42) 12550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(42, "1"), "1") # func is never called with one item 12560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item 12570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, 42, (42, 42)) 12580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value 12590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, add, "") 12600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, reduce, add, ()) 12610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(add, [], None), None) 12620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reduce(add, [], 42), 42) 12630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq: 12650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 12660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 12670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, reduce, 42, BadSeq()) 12680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_reload(self): 12700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import marshal 12710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reload(marshal) 12720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import string 12730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reload(string) 12740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ## import sys 12750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ## self.assertRaises(ImportError, reload, sys) 12760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_repr(self): 12780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(''), '\'\'') 12790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(0), '0') 12800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(0L), '0L') 12810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(()), '()') 12820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr([]), '[]') 12830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr({}), '{}') 12840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = [] 12850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a.append(a) 12860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(a), '[[...]]') 12870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = {} 12880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a[0] = a 12890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(a), '{0: {...}}') 12900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_round(self): 12920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(0.0), 0.0) 12930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(0.0)), float) # Will be int in 3.0. 12940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(1.0), 1.0) 12950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(10.0), 10.0) 12960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(1000000000.0), 1000000000.0) 12970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(1e20), 1e20) 12980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-1.0), -1.0) 13000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-10.0), -10.0) 13010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-1000000000.0), -1000000000.0) 13020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-1e20), -1e20) 13030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(0.1), 0.0) 13050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(1.1), 1.0) 13060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(10.1), 10.0) 13070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(1000000000.1), 1000000000.0) 13080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-1.1), -1.0) 13100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-10.1), -10.0) 13110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-1000000000.1), -1000000000.0) 13120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(0.9), 1.0) 13140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(9.9), 10.0) 13150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(999999999.9), 1000000000.0) 13160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-0.9), -1.0) 13180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-9.9), -10.0) 13190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-999999999.9), -1000000000.0) 13200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-8.0, -1), -10.0) 13220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(-8.0, -1)), float) 13230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(-8.0, 0)), float) 13250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(-8.0, 1)), float) 13260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Check half rounding behaviour. 13280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(5.5), 6) 13290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(6.5), 7) 13300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-5.5), -6) 13310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-6.5), -7) 13320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Check behavior on ints 13340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(0), 0) 13350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(8), 8) 13360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(-8), -8) 13370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(0)), float) # Will be int in 3.0. 13380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(-8, -1)), float) 13390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(-8, 0)), float) 13400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(round(-8, 1)), float) 13410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test new kwargs 13430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(number=-8.0, ndigits=-1), -10.0) 13440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, round) 13460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test generic rounding delegation for reals 13480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class TestRound(object): 13490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __float__(self): 13500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 23.0 13510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class TestNoRound(object): 13530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 13540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(TestRound()), 23) 13560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, round, 1, 2, 3) 13580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, round, TestNoRound()) 13590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = TestNoRound() 13610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.__float__ = lambda *args: args 13620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, round, t) 13630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, round, t, 0) 13640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Some versions of glibc for alpha have a bug that affects 13660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # float -> integer rounding (floor, ceil, rint, round) for 13670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # values in the range [2**52, 2**53). See: 13680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # 13690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350 13700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # 13710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We skip this test on Linux/alpha if it would fail. 13720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao linux_alpha = (platform.system().startswith('Linux') and 13730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao platform.machine().startswith('alpha')) 13740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao system_round_bug = round(5e15+1) != 5e15+1 13750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipIf(linux_alpha and system_round_bug, 13760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "test will fail; failure is probably due to a " 13770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "buggy system round function") 13780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_round_large(self): 13790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #1869: integral floats should remain unchanged 13800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(5e15-1), 5e15-1) 13810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(5e15), 5e15) 13820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(5e15+1), 5e15+1) 13830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(5e15+2), 5e15+2) 13840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(round(5e15+3), 5e15+3) 13850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_setattr(self): 13870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao setattr(sys, 'spam', 1) 13880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sys.spam, 1) 13890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, setattr, sys, 1, 'spam') 13900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, setattr) 13910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_sum(self): 13930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sum([]), 0) 13940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sum(range(2,8)), 27) 13950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sum(iter(range(2,8))), 27) 13960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sum(Squares(10)), 285) 13970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sum(iter(Squares(10))), 285) 13980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3]) 13990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum) 14010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum, 42) 14020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum, ['a', 'b', 'c']) 14030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '') 14040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum, [[1], [2], [3]]) 14050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum, [{2:3}]) 14060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3}) 14070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq: 14090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, index): 14100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 14110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, sum, BadSeq()) 14120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty = [] 14140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sum(([x] for x in range(10)), empty) 14150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(empty, []) 14160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_type(self): 14180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(type(''), type('123')) 14190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotEqual(type(''), type(())) 14200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_unichr(self): 14220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 14230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(unichr(32), unicode(' ')) 14240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(unichr(65), unicode('A')) 14250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(unichr(97), unicode('a')) 14260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 14270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unichr(sys.maxunicode), 14280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape') 14290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 14300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, unichr, sys.maxunicode+1) 14310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, unichr) 14320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises((OverflowError, ValueError), unichr, 2**32) 14330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We don't want self in vars(), so these are static methods 14350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @staticmethod 14370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def get_vars_f0(): 14380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return vars() 14390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @staticmethod 14410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def get_vars_f2(): 14420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BuiltinTest.get_vars_f0() 14430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = 1 14440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = 2 14450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return vars() 14460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class C_get_vars(object): 14480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def getDict(self): 14490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return {'a':2} 14500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao __dict__ = property(fget=getDict) 14510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_vars(self): 14530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(set(vars()), set(dir())) 14540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import sys 14550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(set(vars(sys)), set(dir(sys))) 14560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(self.get_vars_f0(), {}) 14570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2}) 14580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, vars, 42, 42) 14590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, vars, 42) 14600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(vars(self.C_get_vars()), {'a':2}) 14610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_zip(self): 14630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = (1, 2, 3) 14640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = (4, 5, 6) 14650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = [(1, 4), (2, 5), (3, 6)] 14660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(zip(a, b), t) 14670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = [4, 5, 6] 14680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(zip(a, b), t) 14690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = (4, 5, 6, 7) 14700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(zip(a, b), t) 14710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class I: 14720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, i): 14730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if i < 0 or i > 2: raise IndexError 14740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return i + 4 14750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(zip(a, I()), t) 14760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(zip(), []) 14770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(zip(*[]), []) 14780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, zip, None) 14790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class G: 14800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 14810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, zip, a, G()) 14820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Make sure zip doesn't try to allocate a billion elements for the 14840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # result list when one of its arguments doesn't say how long it is. 14850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # A MemoryError is the most likely failure mode. 14860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class SequenceWithoutALength: 14870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, i): 14880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if i == 5: 14890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IndexError 14900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 14910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return i 14920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual( 14930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao zip(SequenceWithoutALength(), xrange(2**30)), 14940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao list(enumerate(range(5))) 14950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 14960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadSeq: 14980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __getitem__(self, i): 14990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if i == 5: 15000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise ValueError 15010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 15020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return i 15030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, zip, BadSeq(), BadSeq()) 15040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_format(self): 15060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test the basic machinery of the format() builtin. Don't test 15070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # the specifics of the various formatters 15080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(3, ''), '3') 15090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Returns some classes to use for various tests. There's 15110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # an old-style version, and a new-style version 15120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def classes_new(): 15130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class A(object): 15140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, x): 15150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.x = x 15160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __format__(self, format_spec): 15170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return str(self.x) + format_spec 15180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromA(A): 15190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 15200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Simple(object): pass 15220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromSimple(Simple): 15230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, x): 15240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.x = x 15250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __format__(self, format_spec): 15260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return str(self.x) + format_spec 15270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromSimple2(DerivedFromSimple): pass 15280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 15290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # In 3.0, classes_classic has the same meaning as classes_new 15310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def classes_classic(): 15320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class A: 15330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, x): 15340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.x = x 15350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __format__(self, format_spec): 15360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return str(self.x) + format_spec 15370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromA(A): 15380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 15390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class Simple: pass 15410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromSimple(Simple): 15420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, x): 15430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.x = x 15440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __format__(self, format_spec): 15450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return str(self.x) + format_spec 15460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromSimple2(DerivedFromSimple): pass 15470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 15480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): 15500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(A(3), 'spec'), '3spec') 15510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') 15520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') 15530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), 15540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao '10abcdef') 15550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class_test(*classes_new()) 15570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class_test(*classes_classic()) 15580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def empty_format_spec(value): 15600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # test that: 15610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # format(x, '') == str(x) 15620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # format(x) == str(x) 15630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(value, ""), str(value)) 15640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(value), str(value)) 15650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # for builtin types, format(x, "") == str(x) 15670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(17**13) 15680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(1.0) 15690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(3.1415e104) 15700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(-3.1415e104) 15710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(3.1415e-104) 15720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(-3.1415e-104) 15730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(object) 15740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao empty_format_spec(None) 15750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # TypeError because self.__format__ returns the wrong type 15770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class BadFormatResult: 15780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __format__(self, format_spec): 15790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 1.0 15800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, format, BadFormatResult(), "") 15810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # TypeError because format_spec is not unicode or str 15830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, format, object(), 4) 15840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, format, object(), object()) 15850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # tests for object.__format__ really belong elsewhere, but 15870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # there's no good place to put them 15880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao x = object().__format__('') 15890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(x.startswith('<object object at')) 15900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # first argument to object.__format__ must be string 15920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, object().__format__, 3) 15930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, object().__format__, object()) 15940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, object().__format__, None) 15950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # -------------------------------------------------------------------- 15970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #7994: object.__format__ with a non-empty format string is 15980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # pending deprecated 15990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_deprecated_format_string(obj, fmt_str, should_raise_warning): 16000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with warnings.catch_warnings(record=True) as w: 16010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao warnings.simplefilter("always", PendingDeprecationWarning) 16020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao format(obj, fmt_str) 16030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if should_raise_warning: 16040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(w), 1) 16050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(w[0].message, PendingDeprecationWarning) 16060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIn('object.__format__ with a non-empty format ' 16070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'string', str(w[0].message)) 16080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 16090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(w), 0) 16100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fmt_strs = ['', 's', u'', u's'] 16120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class A: 16140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __format__(self, fmt_str): 16150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return format('', fmt_str) 16160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for fmt_str in fmt_strs: 16180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_deprecated_format_string(A(), fmt_str, False) 16190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class B: 16210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 16220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class C(object): 16240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 16250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for cls in [object, B, C]: 16270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for fmt_str in fmt_strs: 16280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) 16290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # -------------------------------------------------------------------- 16300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # make sure we can take a subclass of str as a format spec 16320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class DerivedFromStr(str): pass 16330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(format(0, DerivedFromStr('10')), ' 0') 16340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_bin(self): 16360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(0), '0b0') 16370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(1), '0b1') 16380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(-1), '-0b1') 16390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(2**65), '0b1' + '0' * 65) 16400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(2**65-1), '0b' + '1' * 65) 16410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65) 16420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65) 16430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_bytearray_translate(self): 16450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao x = bytearray("abc") 16460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, x.translate, "1", 1) 16470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, x.translate, "1"*256, 1) 16480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16490a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass TestSorted(unittest.TestCase): 16500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_basic(self): 16520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = range(100) 16530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao copy = data[:] 16540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao random.shuffle(copy) 16550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, sorted(copy)) 16560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotEqual(data, copy) 16570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data.reverse() 16590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao random.shuffle(copy) 16600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, sorted(copy, cmp=lambda x, y: cmp(y,x))) 16610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotEqual(data, copy) 16620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao random.shuffle(copy) 16630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, sorted(copy, key=lambda x: -x)) 16640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotEqual(data, copy) 16650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao random.shuffle(copy) 16660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, sorted(copy, reverse=1)) 16670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotEqual(data, copy) 16680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_inputtypes(self): 16700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = 'abracadabra' 16710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao types = [list, tuple] 16720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 16730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao types.insert(0, unicode) 16740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for T in types: 16750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sorted(s), sorted(T(s))) 16760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = ''.join(dict.fromkeys(s).keys()) # unique letters only 16780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao types = [set, frozenset, list, tuple, dict.fromkeys] 16790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if have_unicode: 16800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao types.insert(0, unicode) 16810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for T in types: 16820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sorted(s), sorted(T(s))) 16830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_baddecorator(self): 16850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = 'The quick Brown fox Jumped over The lazy Dog'.split() 16860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) 16870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16880a8c90248264a8b26970b4473770bcc3df8515fJosh Gaodef _run_unittest(*args): 16890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with check_py3k_warnings( 16900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (".+ not supported in 3.x", DeprecationWarning), 16910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (".+ is renamed to imp.reload", DeprecationWarning), 16920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ("classic int division", DeprecationWarning)): 16930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao run_unittest(*args) 16940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16950a8c90248264a8b26970b4473770bcc3df8515fJosh Gaodef test_main(verbose=None): 16960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_classes = (BuiltinTest, TestSorted) 16970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _run_unittest(*test_classes) 16990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # verify reference counting 17010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if verbose and hasattr(sys, "gettotalrefcount"): 17020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import gc 17030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao counts = [None] * 5 17040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in xrange(len(counts)): 17050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _run_unittest(*test_classes) 17060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao gc.collect() 17070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao counts[i] = sys.gettotalrefcount() 17080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao print counts 17090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17110a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoif __name__ == "__main__": 17120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_main(verbose=True) 1713