1919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald# Python test set -- built-in functions 23bead0984c802a2f709076bb9c8531fc67f56ee8Guido van Rossum 3a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinsonimport platform 4a4f46e129294c686ef1effdd89c459bd9a624e6dGeorg Brandlimport unittest 5de9b624fb943295263f8140d9d2eda393348b8ecGeorg Brandlfrom test.test_support import fcmp, have_unicode, TESTFN, unlink, \ 607627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna run_unittest, check_py3k_warnings 7d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smithimport warnings 83b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettingerfrom operator import neg 93bead0984c802a2f709076bb9c8531fc67f56ee8Guido van Rossum 1007627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xiclunaimport sys, cStringIO, random, UserDict 113bead0984c802a2f709076bb9c8531fc67f56ee8Guido van Rossum 123b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger# count the number of test runs. 133b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger# used to skip running test_execfile() multiple times 144e1be94bc6c7ec21daf1de030cc59c9c61b498f8Georg Brandl# and to create unique strings to intern in test_intern() 153b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettingernumruns = 0 163b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 17919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwaldclass Squares: 183bead0984c802a2f709076bb9c8531fc67f56ee8Guido van Rossum 19919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __init__(self, max): 20919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.max = max 21919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.sofar = [] 22919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 23919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __len__(self): return len(self.sofar) 24919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 25919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, i): 26919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if not 0 <= i < self.max: raise IndexError 27919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald n = len(self.sofar) 28919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald while n <= i: 29919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.sofar.append(n*n) 30919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald n += 1 31919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return self.sofar[i] 32919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 33919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwaldclass StrSquares: 34919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 35919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __init__(self, max): 36919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.max = max 37919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.sofar = [] 38919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 39919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __len__(self): 40919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return len(self.sofar) 41919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 42919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, i): 43919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if not 0 <= i < self.max: 44919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise IndexError 45919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald n = len(self.sofar) 46919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald while n <= i: 47919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.sofar.append(str(n*n)) 48919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald n += 1 49919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return self.sofar[i] 50919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 51919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwaldclass BitBucket: 52919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def write(self, line): 53919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 54919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 55919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 5696229b191814556622b575fd320e822f918f355aRaymond Hettingerclass TestFailingBool: 5796229b191814556622b575fd320e822f918f355aRaymond Hettinger def __nonzero__(self): 5896229b191814556622b575fd320e822f918f355aRaymond Hettinger raise RuntimeError 5996229b191814556622b575fd320e822f918f355aRaymond Hettinger 6096229b191814556622b575fd320e822f918f355aRaymond Hettingerclass TestFailingIter: 6196229b191814556622b575fd320e822f918f355aRaymond Hettinger def __iter__(self): 6296229b191814556622b575fd320e822f918f355aRaymond Hettinger raise RuntimeError 6396229b191814556622b575fd320e822f918f355aRaymond Hettinger 64919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwaldclass BuiltinTest(unittest.TestCase): 65919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 66919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_import(self): 67919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald __import__('sys') 68919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald __import__('time') 69919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald __import__('string') 705240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl __import__(name='sys') 715240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl __import__(name='time', level=0) 72919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ImportError, __import__, 'spamspam') 73919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, __import__, 1, 2, 3, 4) 748ddab27182d7d00f32f423955d2344b8ba40b9d7Thomas Wouters self.assertRaises(ValueError, __import__, '') 755240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl self.assertRaises(TypeError, __import__, 'sys', name='sys') 76919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 77919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_abs(self): 78919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # int 79919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(0), 0) 80919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(1234), 1234) 81919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(-1234), 1234) 82820d6ac9d7c2743e6804914471159a1ca74cbd41Martin v. Löwis self.assertTrue(abs(-sys.maxint-1) > 0) 83919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # float 84919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(0.0), 0.0) 85919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(3.14), 3.14) 86919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(-3.14), 3.14) 87919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # long 88919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(0L), 0L) 89919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(1234L), 1234L) 90919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(abs(-1234L), 1234L) 91919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # str 92919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, abs, 'a') 9320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson # bool 9420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(abs(True), 1) 9520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(abs(False), 0) 9620665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson # other 9720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, abs) 9820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, abs, None) 9920665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class AbsClass(object): 10020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson def __abs__(self): 10120665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson return -5 10220665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(abs(AbsClass()), -5) 103919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 10496229b191814556622b575fd320e822f918f355aRaymond Hettinger def test_all(self): 10596229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(all([2, 4, 6]), True) 10696229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(all([2, None, 6]), False) 10796229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6]) 10896229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(RuntimeError, all, TestFailingIter()) 10996229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(TypeError, all, 10) # Non-iterable 11096229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(TypeError, all) # No args 11196229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args 11296229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(all([]), True) # Empty iterator 1137d0eb4b234bacab520104b6c797f69b101baad64Ezio Melotti self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit 11496229b191814556622b575fd320e822f918f355aRaymond Hettinger S = [50, 60] 11596229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(all(x > 42 for x in S), True) 11696229b191814556622b575fd320e822f918f355aRaymond Hettinger S = [50, 40, 60] 11796229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(all(x > 42 for x in S), False) 11896229b191814556622b575fd320e822f918f355aRaymond Hettinger 11996229b191814556622b575fd320e822f918f355aRaymond Hettinger def test_any(self): 12096229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(any([None, None, None]), False) 12196229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(any([None, 4, None]), True) 12296229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6]) 1239b3085cdf5a99e544fd376b9019544cb6c5de36bR David Murray self.assertRaises(RuntimeError, any, TestFailingIter()) 12496229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(TypeError, any, 10) # Non-iterable 12596229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(TypeError, any) # No args 12696229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args 12796229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(any([]), False) # Empty iterator 1287d0eb4b234bacab520104b6c797f69b101baad64Ezio Melotti self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit 12996229b191814556622b575fd320e822f918f355aRaymond Hettinger S = [40, 60, 30] 13096229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(any(x > 42 for x in S), True) 13196229b191814556622b575fd320e822f918f355aRaymond Hettinger S = [10, 20, 30] 13296229b191814556622b575fd320e822f918f355aRaymond Hettinger self.assertEqual(any(x > 42 for x in S), False) 13396229b191814556622b575fd320e822f918f355aRaymond Hettinger 1347ccbca93a27e22f0b06316b0d9760fbf7b19cbdaArmin Rigo def test_neg(self): 1357ccbca93a27e22f0b06316b0d9760fbf7b19cbdaArmin Rigo x = -sys.maxint-1 1365c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(isinstance(x, int)) 1377ccbca93a27e22f0b06316b0d9760fbf7b19cbdaArmin Rigo self.assertEqual(-x, sys.maxint+1) 1387ccbca93a27e22f0b06316b0d9760fbf7b19cbdaArmin Rigo 139919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_apply(self): 140919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def f0(*args): 141919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(args, ()) 142919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def f1(a1): 143919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(a1, 1) 144919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def f2(a1, a2): 145919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(a1, 1) 146919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(a2, 2) 147919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def f3(a1, a2, a3): 148919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(a1, 1) 149919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(a2, 2) 150919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(a3, 3) 151919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald apply(f0, ()) 152919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald apply(f1, (1,)) 153919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald apply(f2, (1, 2)) 154919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald apply(f3, (1, 2, 3)) 155919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 156919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # A PyCFunction that takes only positional parameters should allow an 157919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # empty keyword dictionary to pass without a complaint, but raise a 158919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # TypeError if the dictionary is non-empty. 159919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald apply(id, (1,), {}) 160919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, apply, id, (1,), {"foo": 1}) 161919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, apply) 162919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, apply, id, 42) 163919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, apply, id, (42,), 42) 164919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 165919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_callable(self): 1665c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(callable(len)) 16720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable("a")) 16820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(callable)) 16920665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(lambda x, y: x + y)) 17020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable(__builtins__)) 171919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def f(): pass 1725c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(callable(f)) 17320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson 17420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class Classic: 175919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def meth(self): pass 17620665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(Classic)) 17720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson c = Classic() 17820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(c.meth)) 17920665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable(c)) 18020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson 18120665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class NewStyle(object): 18220665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson def meth(self): pass 18320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(NewStyle)) 18420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson n = NewStyle() 18520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(n.meth)) 18620665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable(n)) 18720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson 18820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson # Classic and new-style classes evaluate __call__() differently 18920665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson c.__call__ = None 19020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(c)) 19120665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson del c.__call__ 19220665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable(c)) 19320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson n.__call__ = None 19420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable(n)) 19520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson del n.__call__ 19620665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertFalse(callable(n)) 19720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson 19820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class N2(object): 199919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __call__(self): pass 20020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson n2 = N2() 20120665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(n2)) 20220665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class N3(N2): pass 20320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson n3 = N3() 20420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertTrue(callable(n3)) 205919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 206919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_chr(self): 207919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(chr(32), ' ') 208919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(chr(65), 'A') 209919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(chr(97), 'a') 210919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(chr(0xff), '\xff') 211919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, chr, 256) 212919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, chr) 213919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 214919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_cmp(self): 215919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(cmp(-1, 1), -1) 216919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(cmp(1, -1), 1) 217919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(cmp(1, 1), 0) 2182b3eb4062c5e50abf854f7e68038243ca7c07217Armin Rigo # verify that circular objects are not handled 219919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a = []; a.append(a) 220919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald b = []; b.append(b) 221919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald from UserList import UserList 222919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald c = UserList(); c.append(c) 2232b3eb4062c5e50abf854f7e68038243ca7c07217Armin Rigo self.assertRaises(RuntimeError, cmp, a, b) 2242b3eb4062c5e50abf854f7e68038243ca7c07217Armin Rigo self.assertRaises(RuntimeError, cmp, b, c) 2252b3eb4062c5e50abf854f7e68038243ca7c07217Armin Rigo self.assertRaises(RuntimeError, cmp, c, a) 2262b3eb4062c5e50abf854f7e68038243ca7c07217Armin Rigo self.assertRaises(RuntimeError, cmp, a, c) 2272b3eb4062c5e50abf854f7e68038243ca7c07217Armin Rigo # okay, now break the cycles 228919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a.pop(); b.pop(); c.pop() 229919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, cmp) 230919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 231919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_coerce(self): 2325c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) 233919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(coerce(1, 1L), (1L, 1L)) 2345c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1))) 235919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, coerce) 236919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadNumber: 237919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __coerce__(self, other): 238919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 239919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, coerce, 42, BadNumber()) 240abcb0c03ade3cee52b71362f57b16af3e00c743bNeal Norwitz self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000)) 241919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 242919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_compile(self): 243919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald compile('print 1\n', '', 'exec') 244f032f86e9e828dfe1147852783aa6784e3ddf610Just van Rossum bom = '\xef\xbb\xbf' 245f032f86e9e828dfe1147852783aa6784e3ddf610Just van Rossum compile(bom + 'print 1\n', '', 'exec') 2465240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl compile(source='pass', filename='?', mode='exec') 2475240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl compile(dont_inherit=0, filename='tmp', source='0', mode='eval') 2485240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl compile('pass', '?', dont_inherit=1, mode='exec') 249919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, compile) 250919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode') 251919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff) 252fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') 2535240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl self.assertRaises(TypeError, compile, 'pass', '?', 'exec', 2545240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl mode='eval', source='0', filename='tmp') 2553aaf42c6139ed211a59b200130d1d205982b9818Just van Rossum if have_unicode: 2563aaf42c6139ed211a59b200130d1d205982b9818Just van Rossum compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec') 257fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec') 258fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad') 259919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 2605240d7416c739e22298463cb08ba8aad7c762a4aGeorg Brandl 261919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_delattr(self): 262919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald import sys 263919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.spam = 1 264919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald delattr(sys, 'spam') 265919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, delattr) 266919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 267919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_dir(self): 268871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(wrong number of arguments) 269919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, dir, 42, 42) 270919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 271871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir() - local scope 272871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl local_var = 1 273aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn('local_var', dir()) 274871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 275871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(module) 276871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl import sys 277aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn('exit', dir(sys)) 278871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 279871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(module_with_invalid__dict__) 280871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl import types 281871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl class Foo(types.ModuleType): 282871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl __dict__ = 8 283871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl f = Foo("foo") 284871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl self.assertRaises(TypeError, dir, f) 285871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 286871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(type) 287aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn("strip", dir(str)) 288aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertNotIn("__mro__", dir(str)) 289871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 290871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(obj) 291871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl class Foo(object): 292871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl def __init__(self): 293871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl self.x = 7 294871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl self.y = 8 295871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl self.z = 9 296871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl f = Foo() 297aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn("y", dir(f)) 298871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 299871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(obj_no__dict__) 300871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl class Foo(object): 301871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl __slots__ = [] 302871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl f = Foo() 303aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn("__repr__", dir(f)) 304871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 305871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(obj_no__class__with__dict__) 306871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # (an ugly trick to cause getattr(f, "__class__") to fail) 307871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl class Foo(object): 308871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl __slots__ = ["__class__", "__dict__"] 309871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl def __init__(self): 310871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl self.bar = "wow" 311871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl f = Foo() 312aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertNotIn("__repr__", dir(f)) 313aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn("bar", dir(f)) 314871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 315871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(obj_using __dir__) 316871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl class Foo(object): 317871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl def __dir__(self): 318871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl return ["kan", "ga", "roo"] 319871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl f = Foo() 3205c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(dir(f) == ["ga", "kan", "roo"]) 321871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 322871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl # dir(obj__dir__not_list) 323871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl class Foo(object): 324871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl def __dir__(self): 325871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl return 7 326871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl f = Foo() 327871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl self.assertRaises(TypeError, dir, f) 328871f1bc6011c1644b1be2e87518c435e7fb552adGeorg Brandl 329919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_divmod(self): 330919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(12, 7), (1, 5)) 331919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(-12, 7), (-2, 2)) 332919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(12, -7), (-2, -2)) 333919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(-12, -7), (1, -5)) 334919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 335919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(12L, 7L), (1L, 5L)) 336919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(-12L, 7L), (-2L, 2L)) 337919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(12L, -7L), (-2L, -2L)) 338919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(-12L, -7L), (1L, -5L)) 339919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 340919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(12, 7L), (1, 5L)) 341919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(-12, 7L), (-2, 2L)) 342919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(12L, -7), (-2L, -2)) 343919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(divmod(-12L, -7), (1L, -5)) 344919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 3455ea7e31076ad80af028d6cb0fa5d4e17f2b467faRaymond Hettinger self.assertEqual(divmod(-sys.maxint-1, -1), 3465ea7e31076ad80af028d6cb0fa5d4e17f2b467faRaymond Hettinger (sys.maxint+1, 0)) 3475ea7e31076ad80af028d6cb0fa5d4e17f2b467faRaymond Hettinger 3485c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) 3495c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) 3505c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) 3515c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) 352919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 353919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, divmod) 354919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 355919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_eval(self): 356919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval('1+1'), 2) 357919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(' 1+1\n'), 2) 358919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald globals = {'a': 1, 'b': 2} 359919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald locals = {'b': 200, 'c': 300} 360919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval('a', globals) , 1) 361919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval('a', globals, locals), 1) 362919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval('b', globals, locals), 200) 363919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval('c', globals, locals), 300) 364919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if have_unicode: 365919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(unicode('1+1')), 2) 366919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(unicode(' 1+1\n')), 2) 367919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald globals = {'a': 1, 'b': 2} 368919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald locals = {'b': 200, 'c': 300} 369919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if have_unicode: 370919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(unicode('a'), globals), 1) 371919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(unicode('a'), globals, locals), 1) 372919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(unicode('b'), globals, locals), 200) 373919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(eval(unicode('c'), globals, locals), 300) 374f032f86e9e828dfe1147852783aa6784e3ddf610Just van Rossum bom = '\xef\xbb\xbf' 375f032f86e9e828dfe1147852783aa6784e3ddf610Just van Rossum self.assertEqual(eval(bom + 'a', globals, locals), 1) 3763aaf42c6139ed211a59b200130d1d205982b9818Just van Rossum self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals), 3773aaf42c6139ed211a59b200130d1d205982b9818Just van Rossum unicode('\xc3\xa5', 'utf8')) 378919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, eval) 379919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, eval, ()) 380919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 381214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger def test_general_eval(self): 382214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger # Tests that general mappings can be used for the locals argument 383214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 384214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger class M: 385214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger "Test mapping interface versus possible calls from eval()." 386214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger def __getitem__(self, key): 387214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger if key == 'a': 388214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger return 12 389214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger raise KeyError 390214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger def keys(self): 391214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger return list('xyz') 392214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 393214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger m = M() 394214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger g = globals() 395214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('a', g, m), 12) 396214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertRaises(NameError, eval, 'b', g, m) 397214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('dir()', g, m), list('xyz')) 398214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('globals()', g, m), g) 399214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('locals()', g, m), m) 400513ffe81122274973d2adeff13345589d4313d47Raymond Hettinger self.assertRaises(TypeError, eval, 'a', m) 40166bd23322567a9ef0ad7bbe2436fef73b18bc9dbRaymond Hettinger class A: 40266bd23322567a9ef0ad7bbe2436fef73b18bc9dbRaymond Hettinger "Non-mapping" 40366bd23322567a9ef0ad7bbe2436fef73b18bc9dbRaymond Hettinger pass 40466bd23322567a9ef0ad7bbe2436fef73b18bc9dbRaymond Hettinger m = A() 40566bd23322567a9ef0ad7bbe2436fef73b18bc9dbRaymond Hettinger self.assertRaises(TypeError, eval, 'a', g, m) 406214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 407214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger # Verify that dict subclasses work as well 408214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger class D(dict): 409214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger def __getitem__(self, key): 410214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger if key == 'a': 411214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger return 12 412214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger return dict.__getitem__(self, key) 413214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger def keys(self): 414214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger return list('xyz') 415214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 416214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger d = D() 417214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('a', g, d), 12) 418214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertRaises(NameError, eval, 'b', g, d) 419214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('dir()', g, d), list('xyz')) 420214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('globals()', g, d), g) 421214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(eval('locals()', g, d), d) 422214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 423214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger # Verify locals stores (used by list comps) 424214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger eval('[locals() for i in (2,3)]', g, d) 425214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger eval('[locals() for i in (2,3)]', g, UserDict.UserDict()) 426214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 427214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger class SpreadSheet: 428214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger "Sample application showing nested, calculated lookups." 429214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger _cells = {} 430214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger def __setitem__(self, key, formula): 431214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self._cells[key] = formula 432215f13dd118f67fb8c3d3663dbbe11ed33691c4fMartin Blais def __getitem__(self, key): 433214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger return eval(self._cells[key], globals(), self) 434214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 435214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger ss = SpreadSheet() 436214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger ss['a1'] = '5' 437214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger ss['a2'] = 'a1*6' 438214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger ss['a3'] = 'a2*7' 439214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger self.assertEqual(ss['a3'], 210) 440214b1c3aaea3e83302df9ea37a37b3c7548b92b1Raymond Hettinger 4412a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger # Verify that dir() catches a non-list returned by eval 4422a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger # SF bug #1004669 4432a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger class C: 4442a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger def __getitem__(self, item): 4452a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger raise KeyError(item) 4462a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger def keys(self): 4472a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger return 'a' 4482a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger self.assertRaises(TypeError, eval, 'dir()', globals(), C()) 4492a7dedef9e3d94fbbad3782fd4757c6b7ba91c09Raymond Hettinger 450919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_filter(self): 451919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld') 452919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9]) 453919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2]) 454919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81]) 455919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81]) 456919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def identity(item): 457919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return 1 458919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald filter(identity, Squares(5)) 459919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, filter) 460919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadSeq(object): 461f2715e076435b74638acb81512c2ee014f75aea2Tim Peters def __getitem__(self, index): 462f2715e076435b74638acb81512c2ee014f75aea2Tim Peters if index<4: 463f2715e076435b74638acb81512c2ee014f75aea2Tim Peters return 42 464f2715e076435b74638acb81512c2ee014f75aea2Tim Peters raise ValueError 465919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, filter, lambda x: x, BadSeq()) 466919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def badfunc(): 467919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 468919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, filter, badfunc, range(5)) 469919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 470bf5170793c7569d648b8cd89a2275768c78d821fWalter Dörwald # test bltinmodule.c::filtertuple() 471919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(None, (1, 2)), (1, 2)) 472919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4)) 473919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, filter, 42, (1, 2)) 474919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 475bf5170793c7569d648b8cd89a2275768c78d821fWalter Dörwald # test bltinmodule.c::filterstring() 476919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(None, "12"), "12") 477919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(filter(lambda x: x>="3", "1234"), "34") 478919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, filter, 42, "12") 479919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class badstr(str): 480919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, index): 481919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 482919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234")) 483bf5170793c7569d648b8cd89a2275768c78d821fWalter Dörwald 484903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald class badstr2(str): 485903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald def __getitem__(self, index): 486903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald return 42 487903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234")) 488903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald 489903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald class weirdstr(str): 490903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald def __getitem__(self, index): 491903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald return weirdstr(2*str.__getitem__(self, index)) 492903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344") 493903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald 4945e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald class shiftstr(str): 4955e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald def __getitem__(self, index): 4965e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald return chr(ord(str.__getitem__(self, index))+1) 4975e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345") 4985e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald 4998afd7571a18593bef57d98ccd68865fd1d400643Martin v. Löwis if have_unicode: 500bf5170793c7569d648b8cd89a2275768c78d821fWalter Dörwald # test bltinmodule.c::filterunicode() 5018afd7571a18593bef57d98ccd68865fd1d400643Martin v. Löwis self.assertEqual(filter(None, unicode("12")), unicode("12")) 5028afd7571a18593bef57d98ccd68865fd1d400643Martin v. Löwis self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34")) 5038afd7571a18593bef57d98ccd68865fd1d400643Martin v. Löwis self.assertRaises(TypeError, filter, 42, unicode("12")) 5048afd7571a18593bef57d98ccd68865fd1d400643Martin v. Löwis self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234"))) 505919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 506903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald class badunicode(unicode): 507903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald def __getitem__(self, index): 508903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald return 42 509903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234")) 510903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald 511903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald class weirdunicode(unicode): 512903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald def __getitem__(self, index): 513903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald return weirdunicode(2*unicode.__getitem__(self, index)) 514903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald self.assertEqual( 515903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344")) 516903f1e0c40cd25489cdf8856ccb1bb8932c819f8Walter Dörwald 5175e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald class shiftunicode(unicode): 5185e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald def __getitem__(self, index): 5195e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald return unichr(ord(unicode.__getitem__(self, index))+1) 5205e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald self.assertEqual( 5215e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald filter(lambda x: x>=unicode("3"), shiftunicode("1234")), 5225e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald unicode("345") 5235e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald ) 5245e61e24d5527246e1602ce6ad428248f5f4eda94Walter Dörwald 525c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald def test_filter_subclasses(self): 526c8cb5d9d6950bb9e3b407c6b4a8dd2831f5edee9Walter Dörwald # test that filter() never returns tuple, str or unicode subclasses 527c8cb5d9d6950bb9e3b407c6b4a8dd2831f5edee9Walter Dörwald # and that the result always goes through __getitem__ 528c8cb5d9d6950bb9e3b407c6b4a8dd2831f5edee9Walter Dörwald funcs = (None, bool, lambda x: True) 529c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald class tuple2(tuple): 5301918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald def __getitem__(self, index): 5311918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald return 2*tuple.__getitem__(self, index) 532c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald class str2(str): 5331918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald def __getitem__(self, index): 5341918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald return 2*str.__getitem__(self, index) 535c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald inputs = { 5368dd19321bbb3b4f94d15ca3a405053265b99e91eWalter Dörwald tuple2: {(): (), (1, 2, 3): (2, 4, 6)}, 5371918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald str2: {"": "", "123": "112233"} 538c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald } 539c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald if have_unicode: 540c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald class unicode2(unicode): 5411918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald def __getitem__(self, index): 5421918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald return 2*unicode.__getitem__(self, index) 5431918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald inputs[unicode2] = { 5441918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald unicode(): unicode(), 5451918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald unicode("123"): unicode("112233") 5461918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald } 5471918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald 5481918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald for (cls, inps) in inputs.iteritems(): 5491918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald for (inp, exp) in inps.iteritems(): 550f2715e076435b74638acb81512c2ee014f75aea2Tim Peters # make sure the output goes through __getitem__ 551f2715e076435b74638acb81512c2ee014f75aea2Tim Peters # even if func is None 552f2715e076435b74638acb81512c2ee014f75aea2Tim Peters self.assertEqual( 553f2715e076435b74638acb81512c2ee014f75aea2Tim Peters filter(funcs[0], cls(inp)), 554f2715e076435b74638acb81512c2ee014f75aea2Tim Peters filter(funcs[1], cls(inp)) 555f2715e076435b74638acb81512c2ee014f75aea2Tim Peters ) 556f2715e076435b74638acb81512c2ee014f75aea2Tim Peters for func in funcs: 5571918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald outp = filter(func, cls(inp)) 5581918f7755e03900224c5a53cca9fc0088c3186d3Walter Dörwald self.assertEqual(outp, exp) 5595c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not isinstance(outp, cls)) 560c3da83fcd7e25ffb1ed15f5adad4efa1c03ebc03Walter Dörwald 561919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_getattr(self): 562919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald import sys 5635c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(getattr(sys, 'stdout') is sys.stdout) 564919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, getattr, sys, 1) 565919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, getattr, sys, 1, "foo") 566919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, getattr) 5674e41a4b64cb9e69d15ebe0cdf752c5e105318a94Walter Dörwald if have_unicode: 5684e41a4b64cb9e69d15ebe0cdf752c5e105318a94Walter Dörwald self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode)) 569919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 570919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_hasattr(self): 571919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald import sys 5725c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(hasattr(sys, 'stdout')) 573919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, hasattr, sys, 1) 574919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, hasattr) 5754e41a4b64cb9e69d15ebe0cdf752c5e105318a94Walter Dörwald if have_unicode: 5764e41a4b64cb9e69d15ebe0cdf752c5e105318a94Walter Dörwald self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode)) 577919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 578b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson # Check that hasattr allows SystemExit and KeyboardInterrupts by 579b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson class A: 580b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson def __getattr__(self, what): 581b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson raise KeyboardInterrupt 582b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") 583b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson class B: 584b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson def __getattr__(self, what): 585b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson raise SystemExit 586b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson self.assertRaises(SystemExit, hasattr, B(), "b") 587b9030f4f0d566c8ae2eeb28ed858f02f3b853ae7Benjamin Peterson 588919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_hash(self): 589919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald hash(None) 590919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(hash(1), hash(1L)) 591919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(hash(1), hash(1.0)) 592919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald hash('spam') 593919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if have_unicode: 594919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(hash('spam'), hash(unicode('spam'))) 595919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald hash((0,1,2,3)) 596919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def f(): pass 597919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, hash, []) 598919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, hash, {}) 599ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis # Bug 1536021: Allow hash to return long objects 600ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis class X: 601ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis def __hash__(self): 602ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis return 2**100 6032623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(type(hash(X())), int) 604ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis class Y(object): 605ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis def __hash__(self): 606ab2f8f7bd556c16a2b30aa8ec05d4c9d8c50d311Martin v. Löwis return 2**100 6072623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(type(hash(Y())), int) 60851fc8c456e9bbb97f42c6990e40019cd4a5eb615Armin Rigo class Z(long): 60951fc8c456e9bbb97f42c6990e40019cd4a5eb615Armin Rigo def __hash__(self): 61051fc8c456e9bbb97f42c6990e40019cd4a5eb615Armin Rigo return self 6112623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(hash(Z(42)), hash(42L)) 612919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 613919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_hex(self): 614919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(hex(16), '0x10') 615919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(hex(16L), '0x10L') 6166c9e130524533263b690e86639a36b6f3e7a8eebGuido van Rossum self.assertEqual(hex(-16), '-0x10') 617919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(hex(-16L), '-0x10L') 618919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, hex, {}) 619919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 620919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_id(self): 621919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id(None) 622919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id(1) 623919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id(1L) 624919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id(1.0) 625919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id('spam') 626919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id((0,1,2,3)) 627919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id([0,1,2,3]) 628919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald id({'spam': 1, 'eggs': 2, 'ham': 3}) 629919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 630919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # Test input() later, together with raw_input 631919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 632cddcafaf6b11f4da66fdccba20a777ccb55b800bAndrew Svetlov # test_int(): see test_int.py for int() tests. 633cddcafaf6b11f4da66fdccba20a777ccb55b800bAndrew Svetlov 634919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_intern(self): 635919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, intern) 6364e1be94bc6c7ec21daf1de030cc59c9c61b498f8Georg Brandl # This fails if the test is run twice with a constant string, 6374e1be94bc6c7ec21daf1de030cc59c9c61b498f8Georg Brandl # therefore append the run counter 6384e1be94bc6c7ec21daf1de030cc59c9c61b498f8Georg Brandl s = "never interned before " + str(numruns) 6395c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(intern(s) is s) 640919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald s2 = s.swapcase().swapcase() 6415c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(intern(s2) is s) 642919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 6434c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton # Subclasses of string can't be interned, because they 6444c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton # provide too much opportunity for insane things to happen. 6454c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton # We don't want them in the interned dict and if they aren't 6464c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton # actually interned, we don't want to create the appearance 647c2077b0d9b5bf99768c6f396bf7ae6c41b682465Ezio Melotti # that they are by allowing intern() to succeed. 6484c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton class S(str): 6494c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton def __hash__(self): 6504c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton return 123 6514c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton 6524c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton self.assertRaises(TypeError, intern, S("abc")) 6534c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton 6544c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton # It's still safe to pass these strings to routines that 6554c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton # call intern internally, e.g. PyObject_SetAttr(). 6564c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton s = S("abc") 6574c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton setattr(s, s, s) 6584c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton self.assertEqual(getattr(s, s), s) 6594c989ddc9c8bd38ab14c9f42511eb567ed219604Jeremy Hylton 660919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_iter(self): 661919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, iter) 662919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, iter, 42, 42) 663919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald lists = [("1", "2"), ["1", "2"], "12"] 664919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if have_unicode: 665919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald lists.append(unicode("12")) 666919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald for l in lists: 667919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald i = iter(l) 668919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(i.next(), '1') 669919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(i.next(), '2') 670919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(StopIteration, i.next) 671919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 672919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_isinstance(self): 673919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class C: 674919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 675919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class D(C): 676919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 677919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class E: 678919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 679919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald c = C() 680919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald d = D() 681919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald e = E() 6825c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(isinstance(c, C)) 6835c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(isinstance(d, C)) 6845c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not isinstance(e, C)) 6855c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not isinstance(c, D)) 6865c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not isinstance('foo', E)) 687919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, isinstance, E, 'foo') 688919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, isinstance) 689919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 690919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_issubclass(self): 691919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class C: 692919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 693919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class D(C): 694919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 695919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class E: 696919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 697919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald c = C() 698919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald d = D() 699919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald e = E() 7005c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(issubclass(D, C)) 7015c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(issubclass(C, C)) 7025c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(not issubclass(C, D)) 703919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, issubclass, 'foo', E) 704919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, issubclass, E, 'foo') 705919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, issubclass) 706919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 707919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_len(self): 708919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(len('123'), 3) 709919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(len(()), 0) 710919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(len((1, 2, 3, 4)), 4) 711919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(len([1, 2, 3, 4]), 4) 712919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(len({}), 0) 713919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(len({'a':1, 'b': 2}), 2) 714919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadSeq: 715919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __len__(self): 716919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 717919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, len, BadSeq()) 71820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, len, 2) 71920665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class ClassicStyle: pass 72020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class NewStyle(object): pass 72120665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(AttributeError, len, ClassicStyle()) 72220665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, len, NewStyle()) 723919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 724919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_map(self): 725919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 726919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(None, 'hello world'), 727919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ['h','e','l','l','o',' ','w','o','r','l','d'] 728919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 729919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 730919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(None, 'abcd', 'efg'), 731919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)] 732919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 733919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 734919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(None, range(10)), 735919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 736919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 737919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 738919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(lambda x: x*x, range(1,4)), 739919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [1, 4, 9] 740919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 741919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald try: 742919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald from math import sqrt 743919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald except ImportError: 744919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def sqrt(x): 745919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return pow(x, 0.5) 746919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 747919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]), 748919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [[4.0, 2.0], [9.0, 3.0]] 749919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 750919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 751919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(lambda x, y: x+y, [1,3,2], [9,1,4]), 752919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [10, 4, 6] 753919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 754919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 755919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def plus(*v): 756919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald accu = 0 757919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald for i in v: accu = accu + i 758919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return accu 759919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 760919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(plus, [1, 3, 7]), 761919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [1, 3, 7] 762919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 763919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 764919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(plus, [1, 3, 7], [4, 9, 2]), 765919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [1+4, 3+9, 7+2] 766919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 767919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 768919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]), 769919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [1+4+1, 3+9+1, 7+2+0] 770919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 771919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 772919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(None, Squares(10)), 773919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 774919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 775919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 776919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(int, Squares(10)), 777919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 778919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 779919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 780919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(None, Squares(3), Squares(2)), 781919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [(0,0), (1,1), (4,None)] 782919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 783919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 784919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald map(max, Squares(3), Squares(2)), 785919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald [0, 1, 4] 786919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 787919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, map) 788919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, map, lambda x: x, 42) 789919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(map(None, [42]), [42]) 790919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadSeq: 791919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, index): 792919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 793919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, map, lambda x: x, BadSeq()) 794fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz def badfunc(x): 795fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz raise RuntimeError 796fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz self.assertRaises(RuntimeError, map, badfunc, range(5)) 797919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 798919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_max(self): 799919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max('123123'), '3') 800919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max(1, 2, 3), 3) 801919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3) 802919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3) 803919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 804919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max(1, 2L, 3.0), 3.0) 805919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max(1L, 2.0, 3), 3) 806919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(max(1.0, 2, 3L), 3L) 807919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 8083b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger for stmt in ( 8093b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "max(key=int)", # no args 8103b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "max(1, key=int)", # single arg not iterable 8113b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "max(1, 2, keystone=int)", # wrong keyword 8123b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "max(1, 2, key=int, abc=int)", # two many keywords 8133b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "max(1, 2, key=1)", # keyfunc is not callable 8143b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger ): 8157f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters try: 8167f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters exec(stmt) in globals() 8177f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters except TypeError: 8187f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters pass 8197f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters else: 8207f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters self.fail(stmt) 8213b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 8223b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(max((1,), key=neg), 1) # one elem iterable 8233b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(max((1,2), key=neg), 1) # two elem iterable 8243b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(max(1, 2, key=neg), 1) # two elems 8253b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 8263b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger data = [random.randrange(200) for i in range(100)] 8273b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger keys = dict((elem, random.randrange(50)) for elem in data) 8283b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger f = keys.__getitem__ 8293b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(max(data, key=f), 8303b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger sorted(reversed(data), key=f)[-1]) 8313b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 832919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_min(self): 833919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min('123123'), '1') 834919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min(1, 2, 3), 1) 835919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1) 836919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1) 837919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 838919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min(1, 2L, 3.0), 1) 839919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min(1L, 2.0, 3), 1L) 840919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(min(1.0, 2, 3L), 1.0) 841919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 842919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, min) 843919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, min, 42) 844919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, min, ()) 845919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadSeq: 846919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, index): 847919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 848919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, min, BadSeq()) 849919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadNumber: 850919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __cmp__(self, other): 851919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 852919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, min, (42, BadNumber())) 853919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 8543b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger for stmt in ( 8553b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "min(key=int)", # no args 8563b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "min(1, key=int)", # single arg not iterable 8573b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "min(1, 2, keystone=int)", # wrong keyword 8583b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "min(1, 2, key=int, abc=int)", # two many keywords 8593b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger "min(1, 2, key=1)", # keyfunc is not callable 8603b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger ): 8617f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters try: 8627f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters exec(stmt) in globals() 8637f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters except TypeError: 8647f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters pass 8657f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters else: 8667f06187d3101acd1af8221fde8b69d96ae8655a4Tim Peters self.fail(stmt) 8673b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 8683b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(min((1,), key=neg), 1) # one elem iterable 8693b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(min((1,2), key=neg), 2) # two elem iterable 8703b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(min(1, 2, key=neg), 2) # two elems 8713b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 8723b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger data = [random.randrange(200) for i in range(100)] 8733b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger keys = dict((elem, random.randrange(50)) for elem in data) 8743b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger f = keys.__getitem__ 8753b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger self.assertEqual(min(data, key=f), 8763b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger sorted(data, key=f)[0]) 8773b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 87828e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl def test_next(self): 87928e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl it = iter(range(2)) 88028e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl self.assertEqual(next(it), 0) 88128e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl self.assertEqual(next(it), 1) 88228e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl self.assertRaises(StopIteration, next, it) 88328e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl self.assertRaises(StopIteration, next, it) 8842623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(next(it, 42), 42) 88528e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl 88628e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl class Iter(object): 88728e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl def __iter__(self): 88828e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl return self 88928e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl def next(self): 89028e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl raise StopIteration 89128e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl 89228e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl it = iter(Iter()) 8932623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(next(it, 42), 42) 89428e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl self.assertRaises(StopIteration, next, it) 89528e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl 89628e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl def gen(): 89728e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl yield 1 89828e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl return 89928e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl 90028e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl it = gen() 9012623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(next(it), 1) 90228e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl self.assertRaises(StopIteration, next, it) 9032623a37852153363335956afab010cb0beb7e74eEzio Melotti self.assertEqual(next(it, 42), 42) 90428e0873f1f89d0d80ab64fabeb805de813ec08e4Georg Brandl 905919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_oct(self): 906919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(oct(100), '0144') 907919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(oct(100L), '0144L') 9086c9e130524533263b690e86639a36b6f3e7a8eebGuido van Rossum self.assertEqual(oct(-100), '-0144') 909919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(oct(-100L), '-0144L') 910919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, oct, ()) 911919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 912919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def write_testfile(self): 913919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # NB the first 4 lines are also used to test input and raw_input, below 914919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp = open(TESTFN, 'w') 915919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald try: 916919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('1+1\n') 917919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('1+1\n') 918919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('The quick brown fox jumps over the lazy dog') 919919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('.\n') 920919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('Dear John\n') 921919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('XXX'*100) 922919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.write('YYY'*100) 923919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald finally: 924919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.close() 925919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 926919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_open(self): 927919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.write_testfile() 928919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp = open(TESTFN, 'r') 929919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald try: 930919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.readline(4), '1+1\n') 931919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.readline(4), '1+1\n') 932919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n') 933919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.readline(4), 'Dear') 934919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.readline(100), ' John\n') 935919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.read(300), 'XXX'*100) 936919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(fp.read(1000), 'YYY'*100) 937919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald finally: 938919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.close() 939919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald unlink(TESTFN) 940919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 941919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_ord(self): 942919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(ord(' '), 32) 943919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(ord('A'), 65) 944919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(ord('a'), 97) 945919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if have_unicode: 946919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode) 947919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, ord, 42) 9484e41a4b64cb9e69d15ebe0cdf752c5e105318a94Walter Dörwald if have_unicode: 9494e41a4b64cb9e69d15ebe0cdf752c5e105318a94Walter Dörwald self.assertRaises(TypeError, ord, unicode("12")) 950919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 951919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_pow(self): 952919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(0,0), 1) 953919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(0,1), 0) 954919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(1,0), 1) 955919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(1,1), 1) 956919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 957919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2,0), 1) 958919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2,10), 1024) 959919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2,20), 1024*1024) 960919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2,30), 1024*1024*1024) 961919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 962919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2,0), 1) 963919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2,1), -2) 964919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2,2), 4) 965919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2,3), -8) 966919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 967919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(0L,0), 1) 968919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(0L,1), 0) 969919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(1L,0), 1) 970919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(1L,1), 1) 971919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 972919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2L,0), 1) 973919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2L,10), 1024) 974919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2L,20), 1024*1024) 975919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(2L,30), 1024*1024*1024) 976919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 977919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2L,0), 1) 978919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2L,1), -2) 979919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2L,2), 4) 980919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(pow(-2L,3), -8) 981919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 982919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(0.,0), 1.) 983919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(0.,1), 0.) 984919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(1.,0), 1.) 985919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(1.,1), 1.) 986919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 987919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(2.,0), 1.) 988919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(2.,10), 1024.) 989919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(2.,20), 1024.*1024.) 990919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.) 991919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 992919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(-2.,0), 1.) 993919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(-2.,1), -2.) 994919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(-2.,2), 4.) 995919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(-2.,3), -8.) 996919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 997919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald for x in 2, 2L, 2.0: 998919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald for y in 10, 10L, 10.0: 999919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald for z in 1000, 1000L, 1000.0: 1000919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if isinstance(x, float) or \ 1001919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald isinstance(y, float) or \ 1002919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald isinstance(z, float): 1003919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, pow, x, y, z) 1004919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald else: 1005919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertAlmostEqual(pow(x, y, z), 24.0) 1006919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1007919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, pow, -1, -2, 3) 1008919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, pow, 1, 2, 0) 1009919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, pow, -1L, -2L, 3L) 1010919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, pow, 1L, 2L, 0L) 10119871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin # Will return complex in 3.0: 10129871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin self.assertRaises(ValueError, pow, -342.43, 0.234) 1013919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1014919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, pow) 1015919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1016919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_range(self): 1017919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(range(3), [0, 1, 2]) 1018919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(range(1, 5), [1, 2, 3, 4]) 1019919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(range(0), []) 1020919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(range(-3), []) 1021919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(range(1, 10, 3), [1, 4, 7]) 1022919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(range(5, -5, -3), [5, 2, -1, -4]) 1023919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1024efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum # Now test range() with longs 1025efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(-2**100), []) 1026efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(0, -2**100), []) 1027efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(0, 2**100, -1), []) 1028efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(0, 2**100, -1), []) 1029efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1030efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum a = long(10 * sys.maxint) 1031efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum b = long(100 * sys.maxint) 1032efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum c = long(50 * sys.maxint) 1033efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1034efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(a, a+2), [a, a+1]) 1035efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(a+2, a, -1L), [a+2, a+1]) 1036efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(range(a+4, a, -2), [a+4, a+2]) 1037efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1038efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum seq = range(a, b, c) 1039aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn(a, seq) 1040aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertNotIn(b, seq) 1041efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(len(seq), 2) 1042efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1043efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum seq = range(b, a, -c) 1044aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn(b, seq) 1045aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertNotIn(a, seq) 1046efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(len(seq), 2) 1047efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1048efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum seq = range(-a, -b, -c) 1049aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertIn(-a, seq) 1050aa98058cc44ba20f35c106d20918c6196b737561Ezio Melotti self.assertNotIn(-b, seq) 1051efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum self.assertEqual(len(seq), 2) 1052efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1053919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, range) 1054919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, range, 1, 2, 3, 4) 1055919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, range, 1, 2, 0) 1056fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz self.assertRaises(ValueError, range, a, a + 1, long(0)) 1057fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz 1058fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz class badzero(int): 1059fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz def __cmp__(self, other): 1060fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz raise RuntimeError 106148361f5cbf419cce361fd1aa0389d6304ad167dbNick Coghlan __hash__ = None # Invalid cmp makes this unhashable 1062fcf4435ae02c3962a8ad71a9539877060c694468Neal Norwitz self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) 1063919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1064481ab89b75d197cf11dd3cf0df71477dc8884d2dMark Dickinson # Reject floats. 1065481ab89b75d197cf11dd3cf0df71477dc8884d2dMark Dickinson self.assertRaises(TypeError, range, 1., 1., 1.) 1066299b3dffd2d4700f0212694aba98d987435cb555Tim Peters self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) 1067efbbb1c60237a9a2997dc4b1ab213e4c6f0da824Guido van Rossum 1068357981e99ddd31009367bd61ac6b476212ee3612Walter Dörwald self.assertRaises(TypeError, range, 0, "spam") 1069357981e99ddd31009367bd61ac6b476212ee3612Walter Dörwald self.assertRaises(TypeError, range, 0, 42, "spam") 1070357981e99ddd31009367bd61ac6b476212ee3612Walter Dörwald 1071357981e99ddd31009367bd61ac6b476212ee3612Walter Dörwald self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) 1072357981e99ddd31009367bd61ac6b476212ee3612Walter Dörwald self.assertRaises(OverflowError, range, 0, 2*sys.maxint) 1073357981e99ddd31009367bd61ac6b476212ee3612Walter Dörwald 1074a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson bignum = 2*sys.maxint 1075a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson smallnum = 42 1076a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson # Old-style user-defined class with __int__ method 1077a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson class I0: 1078a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson def __init__(self, n): 1079a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.n = int(n) 1080a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson def __int__(self): 1081a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson return self.n 1082a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) 1083a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) 1084a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1085a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson # New-style user-defined class with __int__ method 1086a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson class I1(object): 1087a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson def __init__(self, n): 1088a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.n = int(n) 1089a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson def __int__(self): 1090a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson return self.n 1091a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) 1092a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) 1093a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1094a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson # New-style user-defined class with failing __int__ method 1095a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson class IX(object): 1096a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson def __int__(self): 1097a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson raise RuntimeError 1098a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(RuntimeError, range, IX()) 1099a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1100a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson # New-style user-defined class with invalid __int__ method 1101a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson class IN(object): 1102a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson def __int__(self): 1103a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson return "not a number" 1104a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, IN()) 1105a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1106a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson # Exercise various combinations of bad arguments, to check 1107a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson # refcounting logic 1108a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0) 1109a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1110a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0, 0.0) 1111a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0, 0) 1112a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0, 0.0) 1113a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1114a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0, 0, 1.0) 1115a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0, 0.0, 1) 1116a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0, 0.0, 1.0) 1117a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0, 0, 1) 1118a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0, 0, 1.0) 1119a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0, 0.0, 1) 1120a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) 1121a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1122a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1123a8d26688183bec915dbedc665ff081d2a7966c4bMark Dickinson 1124919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_input_and_raw_input(self): 1125919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.write_testfile() 1126919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp = open(TESTFN, 'r') 1127919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald savestdin = sys.stdin 1128919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald savestdout = sys.stdout # Eats the echo 1129919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald try: 1130919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdin = fp 1131919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdout = BitBucket() 1132919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(input(), 2) 1133919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(input('testing\n'), 2) 1134919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.') 1135919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(raw_input('testing\n'), 'Dear John') 11368e24a9678f497ef40b01040d29ff260337da1e77Tim Peters 11377e3ba2a699d6a5660fc7bf239b2090d5b2961b8cGeorg Brandl # SF 1535165: don't segfault on closed stdin 11387e3ba2a699d6a5660fc7bf239b2090d5b2961b8cGeorg Brandl # sys.stdout must be a regular file for triggering 11397e3ba2a699d6a5660fc7bf239b2090d5b2961b8cGeorg Brandl sys.stdout = savestdout 11407e3ba2a699d6a5660fc7bf239b2090d5b2961b8cGeorg Brandl sys.stdin.close() 1141d336e98ed999c80df2fa8829622aa443136c655dGeorg Brandl self.assertRaises(ValueError, input) 11427e3ba2a699d6a5660fc7bf239b2090d5b2961b8cGeorg Brandl 11437e3ba2a699d6a5660fc7bf239b2090d5b2961b8cGeorg Brandl sys.stdout = BitBucket() 1144919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdin = cStringIO.StringIO("NULL\0") 1145919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, input, 42, 42) 1146919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdin = cStringIO.StringIO(" 'whitespace'") 1147919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(input(), 'whitespace') 1148919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdin = cStringIO.StringIO() 1149919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(EOFError, input) 1150ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang 1151ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang # SF 876178: make sure input() respect future options. 1152ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang sys.stdin = cStringIO.StringIO('1/2') 1153ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang sys.stdout = cStringIO.StringIO() 1154ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang exec compile('print input()', 'test_builtin_tmp', 'exec') 1155ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang sys.stdin.seek(0, 0) 1156ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang exec compile('from __future__ import division;print input()', 1157ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang 'test_builtin_tmp', 'exec') 1158ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang sys.stdin.seek(0, 0) 1159ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang exec compile('print input()', 'test_builtin_tmp', 'exec') 1160b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters # The result we expect depends on whether new division semantics 1161b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters # are already in effect. 1162b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters if 1/2 == 0: 1163b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters # This test was compiled with old semantics. 1164b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters expected = ['0', '0.5', '0'] 1165b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters else: 1166b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters # This test was compiled with new semantics (e.g., -Qnew 1167b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters # was given on the command line. 1168b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters expected = ['0.5', '0.5', '0.5'] 1169b82cb8dcd513d49dc674f6973c984628c14cf045Tim Peters self.assertEqual(sys.stdout.getvalue().splitlines(), expected) 1170ff83c2bacc2acd782d20b589a02420df571b89a2Hye-Shik Chang 1171919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald del sys.stdout 1172919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(RuntimeError, input, 'prompt') 1173919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald del sys.stdin 1174919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(RuntimeError, input, 'prompt') 1175919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald finally: 1176919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdin = savestdin 1177919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald sys.stdout = savestdout 1178919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald fp.close() 1179919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald unlink(TESTFN) 1180919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1181919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_reduce(self): 118220665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson add = lambda x, y: x+y 118320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') 1184919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 118520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson reduce(add, [['a', 'c'], [], ['d', 'w']], []), 1186919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ['a','c','d','w'] 1187919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 1188919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040) 1189919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 1190919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald reduce(lambda x, y: x*y, range(2,21), 1L), 1191919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 2432902008176640000L 1192919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 119320665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(reduce(add, Squares(10)), 285) 119420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(reduce(add, Squares(10), 0), 285) 119520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(reduce(add, Squares(0), 0), 0) 1196919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, reduce) 119720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, reduce, 42) 1198919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, reduce, 42, 42) 1199919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, reduce, 42, 42, 42) 120020665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, reduce, None, range(5)) 120120665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, reduce, add, 42) 1202919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(reduce(42, "1"), "1") # func is never called with one item 1203919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item 1204919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, reduce, 42, (42, 42)) 120520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value 120620665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, reduce, add, "") 120720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertRaises(TypeError, reduce, add, ()) 120820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(reduce(add, [], None), None) 120920665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(reduce(add, [], 42), 42) 1210919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1211919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadSeq: 1212919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, index): 1213919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 1214919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, reduce, 42, BadSeq()) 1215919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1216919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_reload(self): 1217919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald import marshal 1218919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald reload(marshal) 1219919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald import string 1220919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald reload(string) 1221919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ## import sys 1222919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ## self.assertRaises(ImportError, reload, sys) 1223919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1224919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_repr(self): 1225919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr(''), '\'\'') 1226919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr(0), '0') 1227919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr(0L), '0L') 1228919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr(()), '()') 1229919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr([]), '[]') 1230919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr({}), '{}') 1231919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a = [] 1232919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a.append(a) 1233919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr(a), '[[...]]') 1234919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a = {} 1235919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a[0] = a 1236919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(repr(a), '{0: {...}}') 1237919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1238919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_round(self): 1239919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(0.0), 0.0) 12402f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(0.0)), float) # Will be int in 3.0. 1241919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(1.0), 1.0) 1242919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(10.0), 10.0) 1243919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(1000000000.0), 1000000000.0) 1244919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(1e20), 1e20) 1245919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1246919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-1.0), -1.0) 1247919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-10.0), -10.0) 1248919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-1000000000.0), -1000000000.0) 1249919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-1e20), -1e20) 1250919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1251919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(0.1), 0.0) 1252919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(1.1), 1.0) 1253919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(10.1), 10.0) 1254919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(1000000000.1), 1000000000.0) 1255919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1256919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-1.1), -1.0) 1257919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-10.1), -10.0) 1258919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-1000000000.1), -1000000000.0) 1259919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1260919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(0.9), 1.0) 1261919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(9.9), 10.0) 1262919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(999999999.9), 1000000000.0) 1263919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1264919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-0.9), -1.0) 1265919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-9.9), -10.0) 1266919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-999999999.9), -1000000000.0) 1267919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1268919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(round(-8.0, -1), -10.0) 12692f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(-8.0, -1)), float) 12702f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 12712f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(-8.0, 0)), float) 12722f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(-8.0, 1)), float) 12732f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 12749871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin # Check half rounding behaviour. 12752f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(round(5.5), 6) 12769871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin self.assertEqual(round(6.5), 7) 12772f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(round(-5.5), -6) 12789871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin self.assertEqual(round(-6.5), -7) 12792f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 12802f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin # Check behavior on ints 12812f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(round(0), 0) 12822f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(round(8), 8) 12832f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(round(-8), -8) 12842f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(0)), float) # Will be int in 3.0. 12852f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(-8, -1)), float) 12862f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(-8, 0)), float) 12872f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(type(round(-8, 1)), float) 1288919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1289ccadf84a1bc1b7908f5dcefd6897f93e174c57b9Georg Brandl # test new kwargs 1290ccadf84a1bc1b7908f5dcefd6897f93e174c57b9Georg Brandl self.assertEqual(round(number=-8.0, ndigits=-1), -10.0) 1291ccadf84a1bc1b7908f5dcefd6897f93e174c57b9Georg Brandl 1292919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, round) 1293919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 12942f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin # test generic rounding delegation for reals 12952f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin class TestRound(object): 12969871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin def __float__(self): 12979871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin return 23.0 12982f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 12992f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin class TestNoRound(object): 13002f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin pass 13012f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 13022f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertEqual(round(TestRound()), 23) 13032f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 13042f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin self.assertRaises(TypeError, round, 1, 2, 3) 13059871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin self.assertRaises(TypeError, round, TestNoRound()) 13062f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 13072f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin t = TestNoRound() 13089871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin t.__float__ = lambda *args: args 13099871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin self.assertRaises(TypeError, round, t) 13109871d8fe22566acf68bf336d04d3a1dbd51f3269Jeffrey Yasskin self.assertRaises(TypeError, round, t, 0) 13112f3c16be73a8562d357b9b13bbb8088e275840a7Jeffrey Yasskin 1312a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # Some versions of glibc for alpha have a bug that affects 1313a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # float -> integer rounding (floor, ceil, rint, round) for 1314a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # values in the range [2**52, 2**53). See: 1315a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # 1316a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350 1317a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # 1318a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # We skip this test on Linux/alpha if it would fail. 1319a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson linux_alpha = (platform.system().startswith('Linux') and 1320a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson platform.machine().startswith('alpha')) 1321a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson system_round_bug = round(5e15+1) != 5e15+1 1322a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson @unittest.skipIf(linux_alpha and system_round_bug, 1323a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson "test will fail; failure is probably due to a " 1324a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson "buggy system round function") 1325a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson def test_round_large(self): 1326a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson # Issue #1869: integral floats should remain unchanged 1327a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson self.assertEqual(round(5e15-1), 5e15-1) 1328a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson self.assertEqual(round(5e15), 5e15) 1329a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson self.assertEqual(round(5e15+1), 5e15+1) 1330a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson self.assertEqual(round(5e15+2), 5e15+2) 1331a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson self.assertEqual(round(5e15+3), 5e15+3) 1332a8fd66d6aaea9cc0a1e7687b082e9fbf5da3cd74Mark Dickinson 1333919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_setattr(self): 1334f2715e076435b74638acb81512c2ee014f75aea2Tim Peters setattr(sys, 'spam', 1) 1335f2715e076435b74638acb81512c2ee014f75aea2Tim Peters self.assertEqual(sys.spam, 1) 1336f2715e076435b74638acb81512c2ee014f75aea2Tim Peters self.assertRaises(TypeError, setattr, sys, 1, 'spam') 1337f2715e076435b74638acb81512c2ee014f75aea2Tim Peters self.assertRaises(TypeError, setattr) 1338919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1339a70b19147fd163744be34745d393af7be603629fAlex Martelli def test_sum(self): 1340a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertEqual(sum([]), 0) 1341a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertEqual(sum(range(2,8)), 27) 1342a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertEqual(sum(iter(range(2,8))), 27) 1343a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertEqual(sum(Squares(10)), 285) 1344a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertEqual(sum(iter(Squares(10))), 285) 1345a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3]) 1346a70b19147fd163744be34745d393af7be603629fAlex Martelli 1347a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum) 1348a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum, 42) 1349a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum, ['a', 'b', 'c']) 1350a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '') 1351a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum, [[1], [2], [3]]) 1352a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum, [{2:3}]) 1353a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3}) 1354a70b19147fd163744be34745d393af7be603629fAlex Martelli 1355a70b19147fd163744be34745d393af7be603629fAlex Martelli class BadSeq: 1356a70b19147fd163744be34745d393af7be603629fAlex Martelli def __getitem__(self, index): 1357a70b19147fd163744be34745d393af7be603629fAlex Martelli raise ValueError 1358a70b19147fd163744be34745d393af7be603629fAlex Martelli self.assertRaises(ValueError, sum, BadSeq()) 1359a70b19147fd163744be34745d393af7be603629fAlex Martelli 1360bfd2dc747979d562916a24c715685d89c194bb56Mark Dickinson empty = [] 1361bfd2dc747979d562916a24c715685d89c194bb56Mark Dickinson sum(([x] for x in range(10)), empty) 1362bfd2dc747979d562916a24c715685d89c194bb56Mark Dickinson self.assertEqual(empty, []) 1363bfd2dc747979d562916a24c715685d89c194bb56Mark Dickinson 1364919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_type(self): 1365919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(type(''), type('123')) 1366919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertNotEqual(type(''), type(())) 1367919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1368919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_unichr(self): 1369919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if have_unicode: 1370919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(unichr(32), unicode(' ')) 1371919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(unichr(65), unicode('A')) 1372919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(unichr(97), unicode('a')) 1373919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 1374919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald unichr(sys.maxunicode), 1375919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape') 1376919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 1377919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, unichr, sys.maxunicode+1) 1378919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, unichr) 137939fd672dfe0bea76d0ae5823b864460757cb423bAmaury Forgeot d'Arc self.assertRaises((OverflowError, ValueError), unichr, 2**32) 1380919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1381fee7b93c60310413db31973c13e5abb4c7620ef4Guido van Rossum # We don't want self in vars(), so these are static methods 1382fee7b93c60310413db31973c13e5abb4c7620ef4Guido van Rossum 1383fee7b93c60310413db31973c13e5abb4c7620ef4Guido van Rossum @staticmethod 1384919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def get_vars_f0(): 1385919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return vars() 1386919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1387fee7b93c60310413db31973c13e5abb4c7620ef4Guido van Rossum @staticmethod 1388919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def get_vars_f2(): 1389919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald BuiltinTest.get_vars_f0() 1390919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a = 1 1391919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald b = 2 1392919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return vars() 1393919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 139420665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson class C_get_vars(object): 139520665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson def getDict(self): 139620665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson return {'a':2} 139720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson __dict__ = property(fget=getDict) 139820665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson 1399919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_vars(self): 1400a690a9967e715663b7a421c9ebdad91381cdf1e4Raymond Hettinger self.assertEqual(set(vars()), set(dir())) 1401919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald import sys 1402a690a9967e715663b7a421c9ebdad91381cdf1e4Raymond Hettinger self.assertEqual(set(vars(sys)), set(dir(sys))) 1403919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(self.get_vars_f0(), {}) 1404919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2}) 1405919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, vars, 42, 42) 1406919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, vars, 42) 140720665599131379d7cd9e6a447551f252a2b115c5Mark Dickinson self.assertEqual(vars(self.C_get_vars()), {'a':2}) 1408919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1409919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def test_zip(self): 1410919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald a = (1, 2, 3) 1411919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald b = (4, 5, 6) 1412919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald t = [(1, 4), (2, 5), (3, 6)] 1413919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(zip(a, b), t) 1414919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald b = [4, 5, 6] 1415919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(zip(a, b), t) 1416919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald b = (4, 5, 6, 7) 1417919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(zip(a, b), t) 1418919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class I: 1419919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, i): 1420919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if i < 0 or i > 2: raise IndexError 1421919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return i + 4 1422919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual(zip(a, I()), t) 1423eaef61511656071194565878dc80c46096d46415Raymond Hettinger self.assertEqual(zip(), []) 1424eaef61511656071194565878dc80c46096d46415Raymond Hettinger self.assertEqual(zip(*[]), []) 1425919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, zip, None) 1426919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class G: 1427919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald pass 1428919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(TypeError, zip, a, G()) 1429919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1430919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # Make sure zip doesn't try to allocate a billion elements for the 1431919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # result list when one of its arguments doesn't say how long it is. 1432919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald # A MemoryError is the most likely failure mode. 1433919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class SequenceWithoutALength: 1434919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, i): 1435919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if i == 5: 1436919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise IndexError 1437919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald else: 1438919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return i 1439919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertEqual( 1440919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald zip(SequenceWithoutALength(), xrange(2**30)), 1441919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald list(enumerate(range(5))) 1442919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald ) 1443919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1444919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald class BadSeq: 1445919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald def __getitem__(self, i): 1446919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald if i == 5: 1447919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald raise ValueError 1448919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald else: 1449919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald return i 1450919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald self.assertRaises(ValueError, zip, BadSeq(), BadSeq()) 1451919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1452a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def test_format(self): 1453a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # Test the basic machinery of the format() builtin. Don't test 1454a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # the specifics of the various formatters 1455a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(3, ''), '3') 1456a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1457a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # Returns some classes to use for various tests. There's 1458a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # an old-style version, and a new-style version 1459a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def classes_new(): 1460a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class A(object): 1461a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __init__(self, x): 1462a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.x = x 1463a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __format__(self, format_spec): 1464a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return str(self.x) + format_spec 1465a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromA(A): 1466a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith pass 1467a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1468a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class Simple(object): pass 1469a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromSimple(Simple): 1470a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __init__(self, x): 1471a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.x = x 1472a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __format__(self, format_spec): 1473a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return str(self.x) + format_spec 1474a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromSimple2(DerivedFromSimple): pass 1475a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 1476a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1477a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # In 3.0, classes_classic has the same meaning as classes_new 1478a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def classes_classic(): 1479a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class A: 1480a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __init__(self, x): 1481a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.x = x 1482a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __format__(self, format_spec): 1483a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return str(self.x) + format_spec 1484a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromA(A): 1485a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith pass 1486a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1487a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class Simple: pass 1488a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromSimple(Simple): 1489a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __init__(self, x): 1490a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.x = x 1491a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __format__(self, format_spec): 1492a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return str(self.x) + format_spec 1493a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromSimple2(DerivedFromSimple): pass 1494a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 1495a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1496a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): 1497a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(A(3), 'spec'), '3spec') 1498a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') 1499a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') 1500a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), 1501a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith '10abcdef') 1502a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1503a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class_test(*classes_new()) 1504a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class_test(*classes_classic()) 1505a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1506a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def empty_format_spec(value): 1507a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # test that: 1508a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # format(x, '') == str(x) 1509a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # format(x) == str(x) 1510a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(value, ""), str(value)) 1511a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(value), str(value)) 1512a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1513a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # for builtin types, format(x, "") == str(x) 1514a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(17**13) 1515a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(1.0) 1516a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(3.1415e104) 1517a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(-3.1415e104) 1518a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(3.1415e-104) 1519a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(-3.1415e-104) 1520a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(object) 1521a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith empty_format_spec(None) 1522a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1523a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # TypeError because self.__format__ returns the wrong type 1524a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class BadFormatResult: 1525a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith def __format__(self, format_spec): 1526a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith return 1.0 1527a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertRaises(TypeError, format, BadFormatResult(), "") 1528a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1529a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # TypeError because format_spec is not unicode or str 1530a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertRaises(TypeError, format, object(), 4) 1531a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertRaises(TypeError, format, object(), object()) 1532a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1533a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # tests for object.__format__ really belong elsewhere, but 1534a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # there's no good place to put them 1535a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith x = object().__format__('') 15365c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931eBenjamin Peterson self.assertTrue(x.startswith('<object object at')) 1537a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1538a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # first argument to object.__format__ must be string 1539a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertRaises(TypeError, object().__format__, 3) 1540a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertRaises(TypeError, object().__format__, object()) 1541a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertRaises(TypeError, object().__format__, None) 1542a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1543d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith # -------------------------------------------------------------------- 1544d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith # Issue #7994: object.__format__ with a non-empty format string is 1545d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith # pending deprecated 1546d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith def test_deprecated_format_string(obj, fmt_str, should_raise_warning): 1547d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith with warnings.catch_warnings(record=True) as w: 1548d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith warnings.simplefilter("always", PendingDeprecationWarning) 1549d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith format(obj, fmt_str) 1550d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith if should_raise_warning: 1551d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith self.assertEqual(len(w), 1) 1552d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith self.assertIsInstance(w[0].message, PendingDeprecationWarning) 1553d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith self.assertIn('object.__format__ with a non-empty format ' 1554d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 'string', str(w[0].message)) 1555d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith else: 1556d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith self.assertEqual(len(w), 0) 1557d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1558d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith fmt_strs = ['', 's', u'', u's'] 1559d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1560d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith class A: 1561d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith def __format__(self, fmt_str): 1562d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith return format('', fmt_str) 1563d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1564d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith for fmt_str in fmt_strs: 1565d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith test_deprecated_format_string(A(), fmt_str, False) 1566d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1567d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith class B: 1568d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith pass 1569d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1570d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith class C(object): 1571d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith pass 1572d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1573d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith for cls in [object, B, C]: 1574d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith for fmt_str in fmt_strs: 1575d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) 1576d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith # -------------------------------------------------------------------- 1577d44b2fc87c2d9bd9e390eb54d50306959d80ba87Eric Smith 1578a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith # make sure we can take a subclass of str as a format spec 1579a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith class DerivedFromStr(str): pass 1580a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith self.assertEqual(format(0, DerivedFromStr('10')), ' 0') 1581a9f7d6248032c9572b4d2024a1be8bd2823af09fEric Smith 1582fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith def test_bin(self): 1583fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(0), '0b0') 1584fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(1), '0b1') 1585fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(-1), '-0b1') 1586fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(2**65), '0b1' + '0' * 65) 1587fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(2**65-1), '0b' + '1' * 65) 1588fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65) 1589fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65) 1590fb0742fe4f5d07b21764479c3c90ce6c4e1e256fEric Smith 1591ec812caf5dd4c8e49c24341852181cca1740277eGeorg Brandl def test_bytearray_translate(self): 1592ec812caf5dd4c8e49c24341852181cca1740277eGeorg Brandl x = bytearray("abc") 1593ec812caf5dd4c8e49c24341852181cca1740277eGeorg Brandl self.assertRaises(ValueError, x.translate, "1", 1) 1594ec812caf5dd4c8e49c24341852181cca1740277eGeorg Brandl self.assertRaises(TypeError, x.translate, "1"*256, 1) 1595ec812caf5dd4c8e49c24341852181cca1740277eGeorg Brandl 15961f70221b861a3714735251d57695b2f472d0599bZachary Wareclass TestExecFile(unittest.TestCase): 15971f70221b861a3714735251d57695b2f472d0599bZachary Ware # Done outside of the method test_z to get the correct scope 15981f70221b861a3714735251d57695b2f472d0599bZachary Ware z = 0 15991f70221b861a3714735251d57695b2f472d0599bZachary Ware f = open(TESTFN, 'w') 16001f70221b861a3714735251d57695b2f472d0599bZachary Ware f.write('z = z+1\n') 16011f70221b861a3714735251d57695b2f472d0599bZachary Ware f.write('z = z*2\n') 16021f70221b861a3714735251d57695b2f472d0599bZachary Ware f.close() 16031f70221b861a3714735251d57695b2f472d0599bZachary Ware with check_py3k_warnings(("execfile.. not supported in 3.x", 16041f70221b861a3714735251d57695b2f472d0599bZachary Ware DeprecationWarning)): 16051f70221b861a3714735251d57695b2f472d0599bZachary Ware execfile(TESTFN) 16061f70221b861a3714735251d57695b2f472d0599bZachary Ware 16071f70221b861a3714735251d57695b2f472d0599bZachary Ware def test_execfile(self): 16081f70221b861a3714735251d57695b2f472d0599bZachary Ware globals = {'a': 1, 'b': 2} 16091f70221b861a3714735251d57695b2f472d0599bZachary Ware locals = {'b': 200, 'c': 300} 16101f70221b861a3714735251d57695b2f472d0599bZachary Ware 16111f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertEqual(self.__class__.z, 2) 16121f70221b861a3714735251d57695b2f472d0599bZachary Ware globals['z'] = 0 16131f70221b861a3714735251d57695b2f472d0599bZachary Ware execfile(TESTFN, globals) 16141f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertEqual(globals['z'], 2) 16151f70221b861a3714735251d57695b2f472d0599bZachary Ware locals['z'] = 0 16161f70221b861a3714735251d57695b2f472d0599bZachary Ware execfile(TESTFN, globals, locals) 16171f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertEqual(locals['z'], 2) 16181f70221b861a3714735251d57695b2f472d0599bZachary Ware 16191f70221b861a3714735251d57695b2f472d0599bZachary Ware class M: 16201f70221b861a3714735251d57695b2f472d0599bZachary Ware "Test mapping interface versus possible calls from execfile()." 16211f70221b861a3714735251d57695b2f472d0599bZachary Ware def __init__(self): 16221f70221b861a3714735251d57695b2f472d0599bZachary Ware self.z = 10 16231f70221b861a3714735251d57695b2f472d0599bZachary Ware def __getitem__(self, key): 16241f70221b861a3714735251d57695b2f472d0599bZachary Ware if key == 'z': 16251f70221b861a3714735251d57695b2f472d0599bZachary Ware return self.z 16261f70221b861a3714735251d57695b2f472d0599bZachary Ware raise KeyError 16271f70221b861a3714735251d57695b2f472d0599bZachary Ware def __setitem__(self, key, value): 16281f70221b861a3714735251d57695b2f472d0599bZachary Ware if key == 'z': 16291f70221b861a3714735251d57695b2f472d0599bZachary Ware self.z = value 16301f70221b861a3714735251d57695b2f472d0599bZachary Ware return 16311f70221b861a3714735251d57695b2f472d0599bZachary Ware raise KeyError 16321f70221b861a3714735251d57695b2f472d0599bZachary Ware 16331f70221b861a3714735251d57695b2f472d0599bZachary Ware locals = M() 16341f70221b861a3714735251d57695b2f472d0599bZachary Ware locals['z'] = 0 16351f70221b861a3714735251d57695b2f472d0599bZachary Ware execfile(TESTFN, globals, locals) 16361f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertEqual(locals['z'], 2) 16371f70221b861a3714735251d57695b2f472d0599bZachary Ware 16381f70221b861a3714735251d57695b2f472d0599bZachary Ware unlink(TESTFN) 16391f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertRaises(TypeError, execfile) 16401f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertRaises(TypeError, execfile, TESTFN, {}, ()) 16411f70221b861a3714735251d57695b2f472d0599bZachary Ware import os 16421f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertRaises(IOError, execfile, os.curdir) 16431f70221b861a3714735251d57695b2f472d0599bZachary Ware self.assertRaises(IOError, execfile, "I_dont_exist") 16441f70221b861a3714735251d57695b2f472d0599bZachary Ware 16451f70221b861a3714735251d57695b2f472d0599bZachary Ware 1646ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smithclass TestSorted(unittest.TestCase): 1647ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith 1648ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith def test_basic(self): 1649ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith data = range(100) 1650ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith copy = data[:] 1651ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith random.shuffle(copy) 1652ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertEqual(data, sorted(copy)) 1653ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertNotEqual(data, copy) 1654ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith 1655ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith data.reverse() 1656ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith random.shuffle(copy) 1657ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertEqual(data, sorted(copy, cmp=lambda x, y: cmp(y,x))) 1658ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertNotEqual(data, copy) 1659ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith random.shuffle(copy) 1660ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertEqual(data, sorted(copy, key=lambda x: -x)) 1661ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertNotEqual(data, copy) 1662ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith random.shuffle(copy) 1663ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertEqual(data, sorted(copy, reverse=1)) 1664ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertNotEqual(data, copy) 1665ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith 1666ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith def test_inputtypes(self): 1667ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith s = 'abracadabra' 1668ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith types = [list, tuple] 1669ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith if have_unicode: 1670ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith types.insert(0, unicode) 1671ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith for T in types: 1672ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertEqual(sorted(s), sorted(T(s))) 1673ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith 1674ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith s = ''.join(dict.fromkeys(s).keys()) # unique letters only 1675ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith types = [set, frozenset, list, tuple, dict.fromkeys] 1676ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith if have_unicode: 1677ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith types.insert(0, unicode) 1678ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith for T in types: 1679ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertEqual(sorted(s), sorted(T(s))) 1680ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith 1681ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith def test_baddecorator(self): 1682ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith data = 'The quick Brown fox Jumped over The lazy Dog'.split() 1683ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) 1684ce584d420d012b7bc3998ad0fb055c464ad58e37Eric Smith 168578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 168678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchakaclass TestType(unittest.TestCase): 168778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def test_new_type(self): 168878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A = type('A', (), {}) 168978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__name__, 'A') 169078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__module__, __name__) 169178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__bases__, (object,)) 169278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(A.__base__, object) 169378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka x = A() 169478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(type(x), A) 169578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(x.__class__, A) 169678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 169778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka class B: 169878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def ham(self): 169978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka return 'ham%d' % self 170078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka C = type('C', (B, int), {'spam': lambda self: 'spam%s' % self}) 170178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__name__, 'C') 170278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__module__, __name__) 170378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__bases__, (B, int)) 170478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(C.__base__, int) 170578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIn('spam', C.__dict__) 170678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertNotIn('ham', C.__dict__) 170778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka x = C(42) 170878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(x, 42) 170978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(type(x), C) 171078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(x.__class__, C) 171178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(x.ham(), 'ham42') 171278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(x.spam(), 'spam42') 171378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(x.bit_length(), 6) 171478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 171578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def test_type_new_keywords(self): 171678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka class B: 171778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def ham(self): 171878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka return 'ham%d' % self 171978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka C = type.__new__(type, 172078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka name='C', 172178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka bases=(B, int), 172278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka dict={'spam': lambda self: 'spam%s' % self}) 172378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__name__, 'C') 172478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__module__, __name__) 172578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__bases__, (B, int)) 172678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIs(C.__base__, int) 172778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertIn('spam', C.__dict__) 172878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertNotIn('ham', C.__dict__) 172978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 173078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def test_type_name(self): 173178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka for name in 'A', '\xc4', 'B.A', '42', '': 173278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A = type(name, (), {}) 173378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__name__, name) 173478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__module__, __name__) 173578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(ValueError): 173678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A\x00B', (), {}) 173778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 173878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type(u'A', (), {}) 173978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 174078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka C = type('C', (), {}) 174178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka for name in 'A', '\xc4', 'B.A', '42', '': 174278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka C.__name__ = name 174378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__name__, name) 174478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(C.__module__, __name__) 174578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 174678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A = type('C', (), {}) 174778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(ValueError): 174878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A.__name__ = 'A\x00B' 174978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__name__, 'C') 175078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 175178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A.__name__ = u'A' 175278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__name__, 'C') 175378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 175478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def test_type_doc(self): 175578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka tests = ('x', '\xc4', 'x\x00y', 42, None) 175678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka if have_unicode: 175778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka tests += (u'\xc4', u'x\x00y') 175878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka for doc in tests: 175978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A = type('A', (), {'__doc__': doc}) 176078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__doc__, doc) 176178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 176278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A = type('A', (), {}) 176378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka self.assertEqual(A.__doc__, None) 176478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(AttributeError): 176578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka A.__doc__ = 'x' 176678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 176778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def test_bad_args(self): 176878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 176978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type() 177078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 177178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', ()) 177278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 177378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), {}, ()) 177478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 177578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), dict={}) 177678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 177778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', [], {}) 177878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 177978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), UserDict.UserDict()) 178078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 178178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (None,), {}) 178278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 178378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (bool,), {}) 178478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 178578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (int, str), {}) 178678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka class B: 178778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka pass 178878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 178978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (B,), {}) 179078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 179178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka def test_bad_slots(self): 179278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 179378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (long,), {'__slots__': 'x'}) 179478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 179578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), {'__slots__': ''}) 179678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 179778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), {'__slots__': '42'}) 179878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 179978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), {'__slots__': 'x\x00y'}) 180078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 180178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), {'__slots__': ('__dict__', '__dict__')}) 180278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 180378a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (), {'__slots__': ('__weakref__', '__weakref__')}) 180478a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 180578a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka class B(object): 180678a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka pass 180778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 180878a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (B,), {'__slots__': '__dict__'}) 180978a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka with self.assertRaises(TypeError): 181078a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka type('A', (B,), {'__slots__': '__weakref__'}) 181178a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 181278a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka 181307627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xiclunadef _run_unittest(*args): 181407627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna with check_py3k_warnings( 181507627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna (".+ not supported in 3.x", DeprecationWarning), 181607627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna (".+ is renamed to imp.reload", DeprecationWarning), 181707627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna ("classic int division", DeprecationWarning)): 181807627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna run_unittest(*args) 181907627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna 18203b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettingerdef test_main(verbose=None): 18211f70221b861a3714735251d57695b2f472d0599bZachary Ware global numruns 18221f70221b861a3714735251d57695b2f472d0599bZachary Ware if not numruns: 18231f70221b861a3714735251d57695b2f472d0599bZachary Ware with check_py3k_warnings( 18241f70221b861a3714735251d57695b2f472d0599bZachary Ware (".+ not supported in 3.x", DeprecationWarning)): 18251f70221b861a3714735251d57695b2f472d0599bZachary Ware run_unittest(TestExecFile) 18261f70221b861a3714735251d57695b2f472d0599bZachary Ware numruns += 1 182778a54c03117711de66169230fc4eba7f0abd79afSerhiy Storchaka test_classes = (BuiltinTest, TestSorted, TestType) 18283b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 182907627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna _run_unittest(*test_classes) 18303b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 18313b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger # verify reference counting 18323b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger if verbose and hasattr(sys, "gettotalrefcount"): 18333b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger import gc 18343b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger counts = [None] * 5 18353b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger for i in xrange(len(counts)): 183607627880813ffaad8d9b90bfe8791ccf588b031bFlorent Xicluna _run_unittest(*test_classes) 18373b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger gc.collect() 18383b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger counts[i] = sys.gettotalrefcount() 18393b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger print counts 18403b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger 1841919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwald 1842919497ea743174665958520a5647ab0ae87ecb0bWalter Dörwaldif __name__ == "__main__": 18433b0c7c20a10349fbedeb3779582280363a46f087Raymond Hettinger test_main(verbose=True) 1844