14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# Python test set -- built-in functions 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport platform 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom test.test_support import fcmp, have_unicode, TESTFN, unlink, \ 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm run_unittest, check_py3k_warnings 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport warnings 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom operator import neg 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport sys, cStringIO, random, UserDict 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# count the number of test runs. 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# used to skip running test_execfile() multiple times 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# and to create unique strings to intern in test_intern() 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmnumruns = 0 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass Squares: 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, max): 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.max = max 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.sofar = [] 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __len__(self): return len(self.sofar) 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not 0 <= i < self.max: raise IndexError 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(self.sofar) 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while n <= i: 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.sofar.append(n*n) 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n += 1 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.sofar[i] 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass StrSquares: 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, max): 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.max = max 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.sofar = [] 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __len__(self): 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return len(self.sofar) 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not 0 <= i < self.max: 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise IndexError 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(self.sofar) 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while n <= i: 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.sofar.append(str(n*n)) 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n += 1 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.sofar[i] 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass BitBucket: 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def write(self, line): 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestFailingBool: 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __nonzero__(self): 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise RuntimeError 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestFailingIter: 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise RuntimeError 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass BuiltinTest(unittest.TestCase): 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_import(self): 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __import__('sys') 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __import__('time') 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __import__('string') 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __import__(name='sys') 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __import__(name='time', level=0) 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ImportError, __import__, 'spamspam') 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, __import__, 1, 2, 3, 4) 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, __import__, '') 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, __import__, 'sys', name='sys') 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_abs(self): 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # int 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(0), 0) 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(1234), 1234) 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(-1234), 1234) 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(abs(-sys.maxint-1) > 0) 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # float 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(0.0), 0.0) 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(3.14), 3.14) 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(-3.14), 3.14) 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # long 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(0L), 0L) 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(1234L), 1234L) 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(-1234L), 1234L) 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # str 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, abs, 'a') 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # bool 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(True), 1) 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(False), 0) 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # other 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, abs) 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, abs, None) 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class AbsClass(object): 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __abs__(self): 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -5 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(AbsClass()), -5) 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_all(self): 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(all([2, 4, 6]), True) 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(all([2, None, 6]), False) 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6]) 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, all, TestFailingIter()) 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, all, 10) # Non-iterable 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, all) # No args 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(all([]), True) # Empty iterator 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm S = [50, 60] 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(all(x > 42 for x in S), True) 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm S = [50, 40, 60] 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(all(x > 42 for x in S), False) 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_any(self): 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(any([None, None, None]), False) 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(any([None, 4, None]), True) 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6]) 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, all, TestFailingIter()) 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, any, 10) # Non-iterable 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, any) # No args 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(any([]), False) # Empty iterator 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm S = [40, 60, 30] 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(any(x > 42 for x in S), True) 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm S = [10, 20, 30] 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(any(x > 42 for x in S), False) 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_neg(self): 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = -sys.maxint-1 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinstance(x, int)) 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(-x, sys.maxint+1) 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_apply(self): 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f0(*args): 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(args, ()) 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f1(a1): 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a1, 1) 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f2(a1, a2): 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a1, 1) 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a2, 2) 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f3(a1, a2, a3): 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a1, 1) 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a2, 2) 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a3, 3) 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm apply(f0, ()) 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm apply(f1, (1,)) 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm apply(f2, (1, 2)) 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm apply(f3, (1, 2, 3)) 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # A PyCFunction that takes only positional parameters should allow an 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # empty keyword dictionary to pass without a complaint, but raise a 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # TypeError if the dictionary is non-empty. 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm apply(id, (1,), {}) 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, apply, id, (1,), {"foo": 1}) 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, apply) 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, apply, id, 42) 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, apply, id, (42,), 42) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_callable(self): 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(len)) 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable("a")) 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(callable)) 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(lambda x, y: x + y)) 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable(__builtins__)) 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(): pass 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(f)) 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Classic: 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def meth(self): pass 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(Classic)) 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = Classic() 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(c.meth)) 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable(c)) 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class NewStyle(object): 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def meth(self): pass 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(NewStyle)) 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = NewStyle() 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(n.meth)) 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable(n)) 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Classic and new-style classes evaluate __call__() differently 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c.__call__ = None 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(c)) 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del c.__call__ 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable(c)) 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n.__call__ = None 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable(n)) 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del n.__call__ 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(callable(n)) 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class N2(object): 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __call__(self): pass 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n2 = N2() 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(n2)) 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class N3(N2): pass 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n3 = N3() 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(callable(n3)) 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chr(self): 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(chr(32), ' ') 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(chr(65), 'A') 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(chr(97), 'a') 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(chr(0xff), '\xff') 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, chr, 256) 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, chr) 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_cmp(self): 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(cmp(-1, 1), -1) 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(cmp(1, -1), 1) 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(cmp(1, 1), 0) 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # verify that circular objects are not handled 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = []; a.append(a) 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = []; b.append(b) 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from UserList import UserList 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = UserList(); c.append(c) 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, cmp, a, b) 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, cmp, b, c) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, cmp, c, a) 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, cmp, a, c) 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # okay, now break the cycles 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.pop(); b.pop(); c.pop() 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cmp) 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_coerce(self): 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(coerce(1, 1L), (1L, 1L)) 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1))) 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, coerce) 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadNumber: 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __coerce__(self, other): 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, coerce, 42, BadNumber()) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000)) 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compile(self): 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compile('print 1\n', '', 'exec') 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bom = '\xef\xbb\xbf' 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compile(bom + 'print 1\n', '', 'exec') 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compile(source='pass', filename='?', mode='exec') 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compile(dont_inherit=0, filename='tmp', source='0', mode='eval') 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compile('pass', '?', dont_inherit=1, mode='exec') 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compile) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode') 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compile, 'pass', '?', 'exec', 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mode='eval', source='0', filename='tmp') 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec') 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec') 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad') 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_delattr(self): 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.spam = 1 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm delattr(sys, 'spam') 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, delattr) 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_dir(self): 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(wrong number of arguments) 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dir, 42, 42) 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir() - local scope 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm local_var = 1 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn('local_var', dir()) 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(module) 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn('exit', dir(sys)) 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(module_with_invalid__dict__) 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import types 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo(types.ModuleType): 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __dict__ = 8 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = Foo("foo") 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dir, f) 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(type) 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn("strip", dir(str)) 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn("__mro__", dir(str)) 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(obj) 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo(object): 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self): 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.x = 7 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.y = 8 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.z = 9 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = Foo() 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn("y", dir(f)) 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(obj_no__dict__) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo(object): 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __slots__ = [] 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = Foo() 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn("__repr__", dir(f)) 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(obj_no__class__with__dict__) 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (an ugly trick to cause getattr(f, "__class__") to fail) 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo(object): 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __slots__ = ["__class__", "__dict__"] 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self): 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.bar = "wow" 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = Foo() 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn("__repr__", dir(f)) 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn("bar", dir(f)) 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(obj_using __dir__) 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo(object): 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __dir__(self): 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ["kan", "ga", "roo"] 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = Foo() 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(dir(f) == ["ga", "kan", "roo"]) 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dir(obj__dir__not_list) 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo(object): 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __dir__(self): 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 7 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = Foo() 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dir, f) 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_divmod(self): 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(12, 7), (1, 5)) 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-12, 7), (-2, 2)) 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(12, -7), (-2, -2)) 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-12, -7), (1, -5)) 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(12L, 7L), (1L, 5L)) 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-12L, 7L), (-2L, 2L)) 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(12L, -7L), (-2L, -2L)) 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-12L, -7L), (1L, -5L)) 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(12, 7L), (1, 5L)) 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-12, 7L), (-2, 2L)) 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(12L, -7), (-2L, -2)) 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-12L, -7), (1L, -5)) 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(divmod(-sys.maxint-1, -1), 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (sys.maxint+1, 0)) 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, divmod) 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_eval(self): 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('1+1'), 2) 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(' 1+1\n'), 2) 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals = {'a': 1, 'b': 2} 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = {'b': 200, 'c': 300} 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('a', globals) , 1) 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('a', globals, locals), 1) 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('b', globals, locals), 200) 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('c', globals, locals), 300) 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode('1+1')), 2) 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode(' 1+1\n')), 2) 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals = {'a': 1, 'b': 2} 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = {'b': 200, 'c': 300} 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode('a'), globals), 1) 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode('a'), globals, locals), 1) 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode('b'), globals, locals), 200) 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode('c'), globals, locals), 300) 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bom = '\xef\xbb\xbf' 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(bom + 'a', globals, locals), 1) 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals), 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unicode('\xc3\xa5', 'utf8')) 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, eval) 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, eval, ()) 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_general_eval(self): 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Tests that general mappings can be used for the locals argument 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class M: 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Test mapping interface versus possible calls from eval()." 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, key): 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if key == 'a': 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 12 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise KeyError 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def keys(self): 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return list('xyz') 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm m = M() 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm g = globals() 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('a', g, m), 12) 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(NameError, eval, 'b', g, m) 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('dir()', g, m), list('xyz')) 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('globals()', g, m), g) 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('locals()', g, m), m) 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, eval, 'a', m) 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class A: 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Non-mapping" 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm m = A() 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, eval, 'a', g, m) 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Verify that dict subclasses work as well 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class D(dict): 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, key): 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if key == 'a': 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 12 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return dict.__getitem__(self, key) 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def keys(self): 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return list('xyz') 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = D() 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('a', g, d), 12) 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(NameError, eval, 'b', g, d) 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('dir()', g, d), list('xyz')) 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('globals()', g, d), g) 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(eval('locals()', g, d), d) 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Verify locals stores (used by list comps) 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm eval('[locals() for i in (2,3)]', g, d) 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm eval('[locals() for i in (2,3)]', g, UserDict.UserDict()) 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class SpreadSheet: 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Sample application showing nested, calculated lookups." 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _cells = {} 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __setitem__(self, key, formula): 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self._cells[key] = formula 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, key): 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return eval(self._cells[key], globals(), self) 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ss = SpreadSheet() 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ss['a1'] = '5' 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ss['a2'] = 'a1*6' 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ss['a3'] = 'a2*7' 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ss['a3'], 210) 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Verify that dir() catches a non-list returned by eval 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # SF bug #1004669 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C: 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, item): 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise KeyError(item) 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def keys(self): 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 'a' 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, eval, 'dir()', globals(), C()) 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Done outside of the method test_z to get the correct scope 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = 0 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = open(TESTFN, 'w') 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f.write('z = z+1\n') 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f.write('z = z*2\n') 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f.close() 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with check_py3k_warnings(("execfile.. not supported in 3.x", 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm DeprecationWarning)): 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm execfile(TESTFN) 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_execfile(self): 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm global numruns 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if numruns: 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm numruns += 1 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals = {'a': 1, 'b': 2} 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = {'b': 200, 'c': 300} 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.__class__.z, 2) 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals['z'] = 0 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm execfile(TESTFN, globals) 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(globals['z'], 2) 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals['z'] = 0 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm execfile(TESTFN, globals, locals) 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(locals['z'], 2) 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class M: 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Test mapping interface versus possible calls from execfile()." 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self): 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.z = 10 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, key): 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if key == 'z': 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.z 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise KeyError 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __setitem__(self, key, value): 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if key == 'z': 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.z = value 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise KeyError 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = M() 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals['z'] = 0 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm execfile(TESTFN, globals, locals) 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(locals['z'], 2) 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unlink(TESTFN) 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, execfile) 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, execfile, TESTFN, {}, ()) 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import os 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IOError, execfile, os.curdir) 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IOError, execfile, "I_dont_exist") 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_filter(self): 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld') 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9]) 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2]) 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81]) 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81]) 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def identity(item): 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm filter(identity, Squares(5)) 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter) 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq(object): 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if index<4: 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, filter, lambda x: x, BadSeq()) 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def badfunc(): 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter, badfunc, range(5)) 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test bltinmodule.c::filtertuple() 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(None, (1, 2)), (1, 2)) 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4)) 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter, 42, (1, 2)) 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test bltinmodule.c::filterstring() 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(None, "12"), "12") 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x>="3", "1234"), "34") 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter, 42, "12") 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class badstr(str): 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234")) 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class badstr2(str): 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234")) 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class weirdstr(str): 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return weirdstr(2*str.__getitem__(self, index)) 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344") 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class shiftstr(str): 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return chr(ord(str.__getitem__(self, index))+1) 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345") 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test bltinmodule.c::filterunicode() 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(None, unicode("12")), unicode("12")) 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34")) 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter, 42, unicode("12")) 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234"))) 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class badunicode(unicode): 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234")) 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class weirdunicode(unicode): 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return weirdunicode(2*unicode.__getitem__(self, index)) 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344")) 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class shiftunicode(unicode): 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return unichr(ord(unicode.__getitem__(self, index))+1) 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm filter(lambda x: x>=unicode("3"), shiftunicode("1234")), 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unicode("345") 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_filter_subclasses(self): 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test that filter() never returns tuple, str or unicode subclasses 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # and that the result always goes through __getitem__ 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm funcs = (None, bool, lambda x: True) 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class tuple2(tuple): 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2*tuple.__getitem__(self, index) 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class str2(str): 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2*str.__getitem__(self, index) 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inputs = { 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tuple2: {(): (), (1, 2, 3): (2, 4, 6)}, 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str2: {"": "", "123": "112233"} 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class unicode2(unicode): 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2*unicode.__getitem__(self, index) 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inputs[unicode2] = { 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unicode(): unicode(), 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unicode("123"): unicode("112233") 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (cls, inps) in inputs.iteritems(): 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (inp, exp) in inps.iteritems(): 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # make sure the output goes through __getitem__ 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # even if func is None 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm filter(funcs[0], cls(inp)), 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm filter(funcs[1], cls(inp)) 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for func in funcs: 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm outp = filter(func, cls(inp)) 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(outp, exp) 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not isinstance(outp, cls)) 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_getattr(self): 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(getattr(sys, 'stdout') is sys.stdout) 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, getattr, sys, 1) 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, getattr, sys, 1, "foo") 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, getattr) 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode)) 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_hasattr(self): 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(hasattr(sys, 'stdout')) 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, hasattr, sys, 1) 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, hasattr) 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode)) 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check that hasattr allows SystemExit and KeyboardInterrupts by 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class A: 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getattr__(self, what): 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise KeyboardInterrupt 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class B: 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getattr__(self, what): 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise SystemExit 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(SystemExit, hasattr, B(), "b") 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_hash(self): 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hash(None) 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(1), hash(1L)) 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(1), hash(1.0)) 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hash('spam') 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash('spam'), hash(unicode('spam'))) 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hash((0,1,2,3)) 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(): pass 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, hash, []) 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, hash, {}) 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Bug 1536021: Allow hash to return long objects 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class X: 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __hash__(self): 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2**100 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(hash(X())), int) 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Y(object): 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __hash__(self): 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2**100 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(hash(Y())), int) 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Z(long): 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __hash__(self): 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(Z(42)), hash(42L)) 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_hex(self): 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hex(16), '0x10') 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hex(16L), '0x10L') 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hex(-16), '-0x10') 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hex(-16L), '-0x10L') 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, hex, {}) 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_id(self): 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id(None) 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id(1) 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id(1L) 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id(1.0) 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id('spam') 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id((0,1,2,3)) 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id([0,1,2,3]) 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id({'spam': 1, 'eggs': 2, 'ham': 3}) 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test input() later, together with raw_input 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_intern(self): 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, intern) 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This fails if the test is run twice with a constant string, 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # therefore append the run counter 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = "never interned before " + str(numruns) 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(intern(s) is s) 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s2 = s.swapcase().swapcase() 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(intern(s2) is s) 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Subclasses of string can't be interned, because they 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # provide too much opportunity for insane things to happen. 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # We don't want them in the interned dict and if they aren't 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # actually interned, we don't want to create the appearance 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # that they are by allowing intern() to succeed. 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class S(str): 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __hash__(self): 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 123 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, intern, S("abc")) 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # It's still safe to pass these strings to routines that 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # call intern internally, e.g. PyObject_SetAttr(). 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = S("abc") 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm setattr(s, s, s) 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(getattr(s, s), s) 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_iter(self): 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, iter) 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, iter, 42, 42) 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lists = [("1", "2"), ["1", "2"], "12"] 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lists.append(unicode("12")) 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for l in lists: 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = iter(l) 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(i.next(), '1') 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(i.next(), '2') 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, i.next) 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_isinstance(self): 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C: 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class D(C): 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class E: 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = C() 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = D() 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm e = E() 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinstance(c, C)) 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinstance(d, C)) 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not isinstance(e, C)) 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not isinstance(c, D)) 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not isinstance('foo', E)) 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, isinstance, E, 'foo') 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, isinstance) 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_issubclass(self): 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C: 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class D(C): 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class E: 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = C() 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = D() 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm e = E() 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(issubclass(D, C)) 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(issubclass(C, C)) 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not issubclass(C, D)) 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, issubclass, 'foo', E) 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, issubclass, E, 'foo') 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, issubclass) 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_len(self): 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len('123'), 3) 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(()), 0) 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len((1, 2, 3, 4)), 4) 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len([1, 2, 3, 4]), 4) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len({}), 0) 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len({'a':1, 'b': 2}), 2) 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq: 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __len__(self): 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, len, BadSeq()) 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, len, 2) 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class ClassicStyle: pass 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class NewStyle(object): pass 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(AttributeError, len, ClassicStyle()) 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, len, NewStyle()) 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_map(self): 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(None, 'hello world'), 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ['h','e','l','l','o',' ','w','o','r','l','d'] 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(None, 'abcd', 'efg'), 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)] 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(None, range(10)), 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(lambda x: x*x, range(1,4)), 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [1, 4, 9] 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from math import sqrt 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ImportError: 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def sqrt(x): 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return pow(x, 0.5) 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]), 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [[4.0, 2.0], [9.0, 3.0]] 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(lambda x, y: x+y, [1,3,2], [9,1,4]), 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [10, 4, 6] 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def plus(*v): 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accu = 0 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in v: accu = accu + i 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return accu 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(plus, [1, 3, 7]), 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [1, 3, 7] 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(plus, [1, 3, 7], [4, 9, 2]), 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [1+4, 3+9, 7+2] 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]), 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [1+4+1, 3+9+1, 7+2+0] 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(None, Squares(10)), 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(int, Squares(10)), 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(None, Squares(3), Squares(2)), 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0,0), (1,1), (4,None)] 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(max, Squares(3), Squares(2)), 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0, 1, 4] 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, map) 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, map, lambda x: x, 42) 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(map(None, [42]), [42]) 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq: 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, map, lambda x: x, BadSeq()) 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def badfunc(x): 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise RuntimeError 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, map, badfunc, range(5)) 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_max(self): 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max('123123'), '3') 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max(1, 2, 3), 3) 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3) 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3) 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max(1, 2L, 3.0), 3.0) 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max(1L, 2.0, 3), 3) 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max(1.0, 2, 3L), 3L) 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for stmt in ( 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "max(key=int)", # no args 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "max(1, key=int)", # single arg not iterable 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "max(1, 2, keystone=int)", # wrong keyword 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "max(1, 2, key=int, abc=int)", # two many keywords 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "max(1, 2, key=1)", # keyfunc is not callable 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ): 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exec(stmt) in globals() 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(stmt) 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max((1,), key=neg), 1) # one elem iterable 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max((1,2), key=neg), 1) # two elem iterable 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max(1, 2, key=neg), 1) # two elems 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = [random.randrange(200) for i in range(100)] 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keys = dict((elem, random.randrange(50)) for elem in data) 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = keys.__getitem__ 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(max(data, key=f), 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sorted(reversed(data), key=f)[-1]) 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_min(self): 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min('123123'), '1') 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(1, 2, 3), 1) 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1) 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1) 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(1, 2L, 3.0), 1) 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(1L, 2.0, 3), 1L) 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(1.0, 2, 3L), 1.0) 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, min) 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, min, 42) 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, min, ()) 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq: 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, min, BadSeq()) 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadNumber: 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __cmp__(self, other): 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, min, (42, BadNumber())) 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for stmt in ( 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "min(key=int)", # no args 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "min(1, key=int)", # single arg not iterable 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "min(1, 2, keystone=int)", # wrong keyword 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "min(1, 2, key=int, abc=int)", # two many keywords 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "min(1, 2, key=1)", # keyfunc is not callable 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ): 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exec(stmt) in globals() 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(stmt) 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min((1,), key=neg), 1) # one elem iterable 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min((1,2), key=neg), 2) # two elem iterable 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(1, 2, key=neg), 2) # two elems 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = [random.randrange(200) for i in range(100)] 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keys = dict((elem, random.randrange(50)) for elem in data) 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = keys.__getitem__ 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(data, key=f), 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sorted(data, key=f)[0]) 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_next(self): 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = iter(range(2)) 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it), 0) 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it), 1) 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, next, it) 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, next, it) 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it, 42), 42) 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Iter(object): 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise StopIteration 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = iter(Iter()) 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it, 42), 42) 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, next, it) 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def gen(): 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield 1 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = gen() 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it), 1) 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, next, it) 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it, 42), 42) 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_oct(self): 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(oct(100), '0144') 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(oct(100L), '0144L') 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(oct(-100), '-0144') 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(oct(-100L), '-0144L') 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, oct, ()) 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def write_testfile(self): 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # NB the first 4 lines are also used to test input and raw_input, below 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp = open(TESTFN, 'w') 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('1+1\n') 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('1+1\n') 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('The quick brown fox jumps over the lazy dog') 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('.\n') 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('Dear John\n') 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('XXX'*100) 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.write('YYY'*100) 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.close() 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_open(self): 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.write_testfile() 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp = open(TESTFN, 'r') 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.readline(4), '1+1\n') 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.readline(4), '1+1\n') 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n') 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.readline(4), 'Dear') 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.readline(100), ' John\n') 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.read(300), 'XXX'*100) 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fp.read(1000), 'YYY'*100) 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.close() 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unlink(TESTFN) 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ord(self): 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ord(' '), 32) 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ord('A'), 65) 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ord('a'), 97) 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode) 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ord, 42) 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ord, unicode("12")) 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_pow(self): 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(0,0), 1) 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(0,1), 0) 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(1,0), 1) 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(1,1), 1) 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2,0), 1) 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2,10), 1024) 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2,20), 1024*1024) 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2,30), 1024*1024*1024) 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2,0), 1) 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2,1), -2) 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2,2), 4) 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2,3), -8) 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(0L,0), 1) 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(0L,1), 0) 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(1L,0), 1) 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(1L,1), 1) 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2L,0), 1) 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2L,10), 1024) 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2L,20), 1024*1024) 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(2L,30), 1024*1024*1024) 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2L,0), 1) 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2L,1), -2) 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2L,2), 4) 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pow(-2L,3), -8) 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(0.,0), 1.) 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(0.,1), 0.) 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(1.,0), 1.) 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(1.,1), 1.) 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(2.,0), 1.) 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(2.,10), 1024.) 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(2.,20), 1024.*1024.) 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.) 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(-2.,0), 1.) 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(-2.,1), -2.) 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(-2.,2), 4.) 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(-2.,3), -8.) 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in 2, 2L, 2.0: 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for y in 10, 10L, 10.0: 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for z in 1000, 1000L, 1000.0: 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(x, float) or \ 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm isinstance(y, float) or \ 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm isinstance(z, float): 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, pow, x, y, z) 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(x, y, z), 24.0) 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, pow, -1, -2, 3) 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow, 1, 2, 0) 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, pow, -1L, -2L, 3L) 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow, 1L, 2L, 0L) 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Will return complex in 3.0: 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow, -342.43, 0.234) 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, pow) 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_range(self): 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(3), [0, 1, 2]) 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(1, 5), [1, 2, 3, 4]) 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(0), []) 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(-3), []) 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(1, 10, 3), [1, 4, 7]) 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(5, -5, -3), [5, 2, -1, -4]) 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Now test range() with longs 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(-2**100), []) 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(0, -2**100), []) 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(0, 2**100, -1), []) 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(0, 2**100, -1), []) 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = long(10 * sys.maxint) 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = long(100 * sys.maxint) 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = long(50 * sys.maxint) 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(a, a+2), [a, a+1]) 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(a+2, a, -1L), [a+2, a+1]) 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(a+4, a, -2), [a+4, a+2]) 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm seq = range(a, b, c) 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(a, seq) 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(b, seq) 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(seq), 2) 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm seq = range(b, a, -c) 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(b, seq) 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(a, seq) 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(seq), 2) 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm seq = range(-a, -b, -c) 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(-a, seq) 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(-b, seq) 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(seq), 2) 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range) 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 1, 2, 3, 4) 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, range, 1, 2, 0) 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, range, a, a + 1, long(0)) 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class badzero(int): 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __cmp__(self, other): 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise RuntimeError 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __hash__ = None # Invalid cmp makes this unhashable 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Reject floats. 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 1., 1., 1.) 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0, "spam") 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0, 42, "spam") 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) 11214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, range, 0, 2*sys.maxint) 11224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bignum = 2*sys.maxint 11244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm smallnum = 42 11254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Old-style user-defined class with __int__ method 11264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class I0: 11274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, n): 11284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.n = int(n) 11294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __int__(self): 11304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.n 11314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) 11324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) 11334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # New-style user-defined class with __int__ method 11354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class I1(object): 11364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, n): 11374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.n = int(n) 11384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __int__(self): 11394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.n 11404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) 11414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) 11424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # New-style user-defined class with failing __int__ method 11444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class IX(object): 11454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __int__(self): 11464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise RuntimeError 11474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, range, IX()) 11484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # New-style user-defined class with invalid __int__ method 11504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class IN(object): 11514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __int__(self): 11524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return "not a number" 11534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, IN()) 11544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Exercise various combinations of bad arguments, to check 11564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # refcounting logic 11574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0) 11584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0, 0.0) 11604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0, 0) 11614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0, 0.0) 11624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0, 0, 1.0) 11644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0, 0.0, 1) 11654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0, 0.0, 1.0) 11664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0, 0, 1) 11674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0, 0, 1.0) 11684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0, 0.0, 1) 11694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) 11704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_input_and_raw_input(self): 11744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.write_testfile() 11754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp = open(TESTFN, 'r') 11764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm savestdin = sys.stdin 11774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm savestdout = sys.stdout # Eats the echo 11784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 11794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin = fp 11804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdout = BitBucket() 11814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(input(), 2) 11824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(input('testing\n'), 2) 11834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.') 11844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(raw_input('testing\n'), 'Dear John') 11854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # SF 1535165: don't segfault on closed stdin 11874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # sys.stdout must be a regular file for triggering 11884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdout = savestdout 11894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin.close() 11904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, input) 11914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdout = BitBucket() 11934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin = cStringIO.StringIO("NULL\0") 11944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, input, 42, 42) 11954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin = cStringIO.StringIO(" 'whitespace'") 11964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(input(), 'whitespace') 11974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin = cStringIO.StringIO() 11984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(EOFError, input) 11994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # SF 876178: make sure input() respect future options. 12014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin = cStringIO.StringIO('1/2') 12024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdout = cStringIO.StringIO() 12034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exec compile('print input()', 'test_builtin_tmp', 'exec') 12044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin.seek(0, 0) 12054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exec compile('from __future__ import division;print input()', 12064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'test_builtin_tmp', 'exec') 12074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin.seek(0, 0) 12084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exec compile('print input()', 'test_builtin_tmp', 'exec') 12094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # The result we expect depends on whether new division semantics 12104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # are already in effect. 12114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1/2 == 0: 12124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This test was compiled with old semantics. 12134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expected = ['0', '0.5', '0'] 12144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 12154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This test was compiled with new semantics (e.g., -Qnew 12164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # was given on the command line. 12174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expected = ['0.5', '0.5', '0.5'] 12184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sys.stdout.getvalue().splitlines(), expected) 12194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del sys.stdout 12214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, input, 'prompt') 12224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del sys.stdin 12234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, input, 'prompt') 12244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: 12254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdin = savestdin 12264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sys.stdout = savestdout 12274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fp.close() 12284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unlink(TESTFN) 12294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_reduce(self): 12314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm add = lambda x, y: x+y 12324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') 12334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 12344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reduce(add, [['a', 'c'], [], ['d', 'w']], []), 12354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ['a','c','d','w'] 12364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 12374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040) 12384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 12394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reduce(lambda x, y: x*y, range(2,21), 1L), 12404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2432902008176640000L 12414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 12424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(add, Squares(10)), 285) 12434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(add, Squares(10), 0), 285) 12444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(add, Squares(0), 0), 0) 12454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce) 12464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, 42) 12474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, 42, 42) 12484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, 42, 42, 42) 12494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, None, range(5)) 12504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, add, 42) 12514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(42, "1"), "1") # func is never called with one item 12524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item 12534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, 42, (42, 42)) 12544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value 12554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, add, "") 12564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, reduce, add, ()) 12574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(add, [], None), None) 12584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(reduce(add, [], 42), 42) 12594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq: 12614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 12624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 12634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, reduce, 42, BadSeq()) 12644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_reload(self): 12664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import marshal 12674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reload(marshal) 12684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import string 12694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reload(string) 12704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ## import sys 12714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ## self.assertRaises(ImportError, reload, sys) 12724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repr(self): 12744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(''), '\'\'') 12754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(0), '0') 12764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(0L), '0L') 12774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(()), '()') 12784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr([]), '[]') 12794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr({}), '{}') 12804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 12814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.append(a) 12824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(a), '[[...]]') 12834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = {} 12844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a[0] = a 12854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(a), '{0: {...}}') 12864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_round(self): 12884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(0.0), 0.0) 12894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(0.0)), float) # Will be int in 3.0. 12904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1.0), 1.0) 12914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(10.0), 10.0) 12924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1000000000.0), 1000000000.0) 12934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e20), 1e20) 12944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1.0), -1.0) 12964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-10.0), -10.0) 12974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1000000000.0), -1000000000.0) 12984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1e20), -1e20) 12994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(0.1), 0.0) 13014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1.1), 1.0) 13024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(10.1), 10.0) 13034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1000000000.1), 1000000000.0) 13044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1.1), -1.0) 13064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-10.1), -10.0) 13074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1000000000.1), -1000000000.0) 13084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(0.9), 1.0) 13104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(9.9), 10.0) 13114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(999999999.9), 1000000000.0) 13124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-0.9), -1.0) 13144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-9.9), -10.0) 13154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-999999999.9), -1000000000.0) 13164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-8.0, -1), -10.0) 13184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(-8.0, -1)), float) 13194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(-8.0, 0)), float) 13214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(-8.0, 1)), float) 13224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check half rounding behaviour. 13244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5.5), 6) 13254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(6.5), 7) 13264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-5.5), -6) 13274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-6.5), -7) 13284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check behavior on ints 13304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(0), 0) 13314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(8), 8) 13324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-8), -8) 13334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(0)), float) # Will be int in 3.0. 13344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(-8, -1)), float) 13354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(-8, 0)), float) 13364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(round(-8, 1)), float) 13374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test new kwargs 13394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(number=-8.0, ndigits=-1), -10.0) 13404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round) 13424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test generic rounding delegation for reals 13444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestRound(object): 13454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 13464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 23.0 13474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestNoRound(object): 13494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 13504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(TestRound()), 23) 13524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, 1, 2, 3) 13544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, TestNoRound()) 13554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = TestNoRound() 13574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t.__float__ = lambda *args: args 13584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, t) 13594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, t, 0) 13604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Some versions of glibc for alpha have a bug that affects 13624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # float -> integer rounding (floor, ceil, rint, round) for 13634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # values in the range [2**52, 2**53). See: 13644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 13654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350 13664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 13674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # We skip this test on Linux/alpha if it would fail. 13684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm linux_alpha = (platform.system().startswith('Linux') and 13694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm platform.machine().startswith('alpha')) 13704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm system_round_bug = round(5e15+1) != 5e15+1 13714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipIf(linux_alpha and system_round_bug, 13724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test will fail; failure is probably due to a " 13734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "buggy system round function") 13744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_round_large(self): 13754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue #1869: integral floats should remain unchanged 13764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5e15-1), 5e15-1) 13774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5e15), 5e15) 13784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5e15+1), 5e15+1) 13794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5e15+2), 5e15+2) 13804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5e15+3), 5e15+3) 13814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_setattr(self): 13834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm setattr(sys, 'spam', 1) 13844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sys.spam, 1) 13854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, setattr, sys, 1, 'spam') 13864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, setattr) 13874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_sum(self): 13894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum([]), 0) 13904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(range(2,8)), 27) 13914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(iter(range(2,8))), 27) 13924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(Squares(10)), 285) 13934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(iter(Squares(10))), 285) 13944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3]) 13954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum) 13974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum, 42) 13984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum, ['a', 'b', 'c']) 13994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '') 14004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum, [[1], [2], [3]]) 14014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum, [{2:3}]) 14024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3}) 14034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq: 14054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, index): 14064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 14074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, sum, BadSeq()) 14084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty = [] 14104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sum(([x] for x in range(10)), empty) 14114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(empty, []) 14124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_type(self): 14144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(''), type('123')) 14154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(type(''), type(())) 14164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_unichr(self): 14184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 14194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(unichr(32), unicode(' ')) 14204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(unichr(65), unicode('A')) 14214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(unichr(97), unicode('a')) 14224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 14234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unichr(sys.maxunicode), 14244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape') 14254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 14264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, unichr, sys.maxunicode+1) 14274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, unichr) 14284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises((OverflowError, ValueError), unichr, 2**32) 14294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # We don't want self in vars(), so these are static methods 14314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @staticmethod 14334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def get_vars_f0(): 14344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return vars() 14354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @staticmethod 14374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def get_vars_f2(): 14384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm BuiltinTest.get_vars_f0() 14394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = 1 14404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = 2 14414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return vars() 14424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C_get_vars(object): 14444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def getDict(self): 14454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return {'a':2} 14464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __dict__ = property(fget=getDict) 14474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_vars(self): 14494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(set(vars()), set(dir())) 14504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys 14514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(set(vars(sys)), set(dir(sys))) 14524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.get_vars_f0(), {}) 14534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2}) 14544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, vars, 42, 42) 14554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, vars, 42) 14564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(vars(self.C_get_vars()), {'a':2}) 14574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_zip(self): 14594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = (1, 2, 3) 14604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = (4, 5, 6) 14614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = [(1, 4), (2, 5), (3, 6)] 14624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(a, b), t) 14634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = [4, 5, 6] 14644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(a, b), t) 14654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = (4, 5, 6, 7) 14664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(a, b), t) 14674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class I: 14684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 14694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if i < 0 or i > 2: raise IndexError 14704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return i + 4 14714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(a, I()), t) 14724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(), []) 14734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(*[]), []) 14744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, zip, None) 14754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class G: 14764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 14774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, zip, a, G()) 14784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Make sure zip doesn't try to allocate a billion elements for the 14804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # result list when one of its arguments doesn't say how long it is. 14814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # A MemoryError is the most likely failure mode. 14824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class SequenceWithoutALength: 14834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 14844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if i == 5: 14854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise IndexError 14864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 14874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return i 14884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual( 14894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zip(SequenceWithoutALength(), xrange(2**30)), 14904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list(enumerate(range(5))) 14914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 14924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadSeq: 14944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 14954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if i == 5: 14964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 14974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 14984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return i 14994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, zip, BadSeq(), BadSeq()) 15004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_format(self): 15024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test the basic machinery of the format() builtin. Don't test 15034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the specifics of the various formatters 15044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3, ''), '3') 15054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Returns some classes to use for various tests. There's 15074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # an old-style version, and a new-style version 15084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def classes_new(): 15094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class A(object): 15104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, x): 15114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.x = x 15124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __format__(self, format_spec): 15134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return str(self.x) + format_spec 15144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromA(A): 15154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 15164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Simple(object): pass 15184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromSimple(Simple): 15194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, x): 15204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.x = x 15214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __format__(self, format_spec): 15224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return str(self.x) + format_spec 15234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromSimple2(DerivedFromSimple): pass 15244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 15254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # In 3.0, classes_classic has the same meaning as classes_new 15274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def classes_classic(): 15284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class A: 15294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, x): 15304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.x = x 15314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __format__(self, format_spec): 15324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return str(self.x) + format_spec 15334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromA(A): 15344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 15354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Simple: pass 15374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromSimple(Simple): 15384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, x): 15394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.x = x 15404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __format__(self, format_spec): 15414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return str(self.x) + format_spec 15424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromSimple2(DerivedFromSimple): pass 15434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 15444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): 15464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(A(3), 'spec'), '3spec') 15474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') 15484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') 15494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), 15504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '10abcdef') 15514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class_test(*classes_new()) 15534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class_test(*classes_classic()) 15544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def empty_format_spec(value): 15564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test that: 15574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # format(x, '') == str(x) 15584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # format(x) == str(x) 15594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(value, ""), str(value)) 15604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(value), str(value)) 15614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # for builtin types, format(x, "") == str(x) 15634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(17**13) 15644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(1.0) 15654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(3.1415e104) 15664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(-3.1415e104) 15674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(3.1415e-104) 15684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(-3.1415e-104) 15694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(object) 15704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm empty_format_spec(None) 15714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # TypeError because self.__format__ returns the wrong type 15734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class BadFormatResult: 15744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __format__(self, format_spec): 15754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1.0 15764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, format, BadFormatResult(), "") 15774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # TypeError because format_spec is not unicode or str 15794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, format, object(), 4) 15804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, format, object(), object()) 15814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # tests for object.__format__ really belong elsewhere, but 15834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # there's no good place to put them 15844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = object().__format__('') 15854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(x.startswith('<object object at')) 15864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # first argument to object.__format__ must be string 15884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, object().__format__, 3) 15894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, object().__format__, object()) 15904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, object().__format__, None) 15914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # -------------------------------------------------------------------- 15934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue #7994: object.__format__ with a non-empty format string is 15944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pending deprecated 15954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_deprecated_format_string(obj, fmt_str, should_raise_warning): 15964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with warnings.catch_warnings(record=True) as w: 15974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm warnings.simplefilter("always", PendingDeprecationWarning) 15984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format(obj, fmt_str) 15994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if should_raise_warning: 16004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(w), 1) 16014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIsInstance(w[0].message, PendingDeprecationWarning) 16024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn('object.__format__ with a non-empty format ' 16034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'string', str(w[0].message)) 16044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 16054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(w), 0) 16064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fmt_strs = ['', 's', u'', u's'] 16084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class A: 16104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __format__(self, fmt_str): 16114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return format('', fmt_str) 16124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt_str in fmt_strs: 16144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_deprecated_format_string(A(), fmt_str, False) 16154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class B: 16174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 16184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C(object): 16204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 16214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for cls in [object, B, C]: 16234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt_str in fmt_strs: 16244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) 16254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # -------------------------------------------------------------------- 16264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # make sure we can take a subclass of str as a format spec 16284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DerivedFromStr(str): pass 16294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(0, DerivedFromStr('10')), ' 0') 16304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_bin(self): 16324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(0), '0b0') 16334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(1), '0b1') 16344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(-1), '-0b1') 16354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(2**65), '0b1' + '0' * 65) 16364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(2**65-1), '0b' + '1' * 65) 16374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65) 16384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65) 16394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_bytearray_translate(self): 16414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = bytearray("abc") 16424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, x.translate, "1", 1) 16434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, x.translate, "1"*256, 1) 16444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestSorted(unittest.TestCase): 16464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_basic(self): 16484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = range(100) 16494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm copy = data[:] 16504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm random.shuffle(copy) 16514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(data, sorted(copy)) 16524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(data, copy) 16534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data.reverse() 16554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm random.shuffle(copy) 16564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(data, sorted(copy, cmp=lambda x, y: cmp(y,x))) 16574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(data, copy) 16584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm random.shuffle(copy) 16594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(data, sorted(copy, key=lambda x: -x)) 16604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(data, copy) 16614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm random.shuffle(copy) 16624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(data, sorted(copy, reverse=1)) 16634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(data, copy) 16644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_inputtypes(self): 16664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = 'abracadabra' 16674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm types = [list, tuple] 16684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 16694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm types.insert(0, unicode) 16704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for T in types: 16714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sorted(s), sorted(T(s))) 16724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = ''.join(dict.fromkeys(s).keys()) # unique letters only 16744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm types = [set, frozenset, list, tuple, dict.fromkeys] 16754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if have_unicode: 16764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm types.insert(0, unicode) 16774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for T in types: 16784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sorted(s), sorted(T(s))) 16794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_baddecorator(self): 16814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = 'The quick Brown fox Jumped over The lazy Dog'.split() 16824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) 16834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef _run_unittest(*args): 16854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with check_py3k_warnings( 16864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (".+ not supported in 3.x", DeprecationWarning), 16874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (".+ is renamed to imp.reload", DeprecationWarning), 16884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ("classic int division", DeprecationWarning)): 16894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm run_unittest(*args) 16904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(verbose=None): 16924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_classes = (BuiltinTest, TestSorted) 16934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _run_unittest(*test_classes) 16954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # verify reference counting 16974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if verbose and hasattr(sys, "gettotalrefcount"): 16984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import gc 16994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm counts = [None] * 5 17004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(len(counts)): 17014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _run_unittest(*test_classes) 17024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm gc.collect() 17034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm counts[i] = sys.gettotalrefcount() 17044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm print counts 17054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == "__main__": 17084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main(verbose=True) 1709