1# Python test set -- built-in functions 2 3import platform 4import unittest 5from test.test_support import fcmp, have_unicode, TESTFN, unlink, \ 6 run_unittest, check_py3k_warnings 7import warnings 8from operator import neg 9 10import sys, cStringIO, random, UserDict 11 12# count the number of test runs. 13# used to skip running test_execfile() multiple times 14# and to create unique strings to intern in test_intern() 15numruns = 0 16 17class Squares: 18 19 def __init__(self, max): 20 self.max = max 21 self.sofar = [] 22 23 def __len__(self): return len(self.sofar) 24 25 def __getitem__(self, i): 26 if not 0 <= i < self.max: raise IndexError 27 n = len(self.sofar) 28 while n <= i: 29 self.sofar.append(n*n) 30 n += 1 31 return self.sofar[i] 32 33class StrSquares: 34 35 def __init__(self, max): 36 self.max = max 37 self.sofar = [] 38 39 def __len__(self): 40 return len(self.sofar) 41 42 def __getitem__(self, i): 43 if not 0 <= i < self.max: 44 raise IndexError 45 n = len(self.sofar) 46 while n <= i: 47 self.sofar.append(str(n*n)) 48 n += 1 49 return self.sofar[i] 50 51class BitBucket: 52 def write(self, line): 53 pass 54 55 56class TestFailingBool: 57 def __nonzero__(self): 58 raise RuntimeError 59 60class TestFailingIter: 61 def __iter__(self): 62 raise RuntimeError 63 64class BuiltinTest(unittest.TestCase): 65 66 def test_import(self): 67 __import__('sys') 68 __import__('time') 69 __import__('string') 70 __import__(name='sys') 71 __import__(name='time', level=0) 72 self.assertRaises(ImportError, __import__, 'spamspam') 73 self.assertRaises(TypeError, __import__, 1, 2, 3, 4) 74 self.assertRaises(ValueError, __import__, '') 75 self.assertRaises(TypeError, __import__, 'sys', name='sys') 76 77 def test_abs(self): 78 # int 79 self.assertEqual(abs(0), 0) 80 self.assertEqual(abs(1234), 1234) 81 self.assertEqual(abs(-1234), 1234) 82 self.assertTrue(abs(-sys.maxint-1) > 0) 83 # float 84 self.assertEqual(abs(0.0), 0.0) 85 self.assertEqual(abs(3.14), 3.14) 86 self.assertEqual(abs(-3.14), 3.14) 87 # long 88 self.assertEqual(abs(0L), 0L) 89 self.assertEqual(abs(1234L), 1234L) 90 self.assertEqual(abs(-1234L), 1234L) 91 # str 92 self.assertRaises(TypeError, abs, 'a') 93 # bool 94 self.assertEqual(abs(True), 1) 95 self.assertEqual(abs(False), 0) 96 # other 97 self.assertRaises(TypeError, abs) 98 self.assertRaises(TypeError, abs, None) 99 class AbsClass(object): 100 def __abs__(self): 101 return -5 102 self.assertEqual(abs(AbsClass()), -5) 103 104 def test_all(self): 105 self.assertEqual(all([2, 4, 6]), True) 106 self.assertEqual(all([2, None, 6]), False) 107 self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6]) 108 self.assertRaises(RuntimeError, all, TestFailingIter()) 109 self.assertRaises(TypeError, all, 10) # Non-iterable 110 self.assertRaises(TypeError, all) # No args 111 self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args 112 self.assertEqual(all([]), True) # Empty iterator 113 self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit 114 S = [50, 60] 115 self.assertEqual(all(x > 42 for x in S), True) 116 S = [50, 40, 60] 117 self.assertEqual(all(x > 42 for x in S), False) 118 119 def test_any(self): 120 self.assertEqual(any([None, None, None]), False) 121 self.assertEqual(any([None, 4, None]), True) 122 self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6]) 123 self.assertRaises(RuntimeError, any, TestFailingIter()) 124 self.assertRaises(TypeError, any, 10) # Non-iterable 125 self.assertRaises(TypeError, any) # No args 126 self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args 127 self.assertEqual(any([]), False) # Empty iterator 128 self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit 129 S = [40, 60, 30] 130 self.assertEqual(any(x > 42 for x in S), True) 131 S = [10, 20, 30] 132 self.assertEqual(any(x > 42 for x in S), False) 133 134 def test_neg(self): 135 x = -sys.maxint-1 136 self.assertTrue(isinstance(x, int)) 137 self.assertEqual(-x, sys.maxint+1) 138 139 def test_apply(self): 140 def f0(*args): 141 self.assertEqual(args, ()) 142 def f1(a1): 143 self.assertEqual(a1, 1) 144 def f2(a1, a2): 145 self.assertEqual(a1, 1) 146 self.assertEqual(a2, 2) 147 def f3(a1, a2, a3): 148 self.assertEqual(a1, 1) 149 self.assertEqual(a2, 2) 150 self.assertEqual(a3, 3) 151 apply(f0, ()) 152 apply(f1, (1,)) 153 apply(f2, (1, 2)) 154 apply(f3, (1, 2, 3)) 155 156 # A PyCFunction that takes only positional parameters should allow an 157 # empty keyword dictionary to pass without a complaint, but raise a 158 # TypeError if the dictionary is non-empty. 159 apply(id, (1,), {}) 160 self.assertRaises(TypeError, apply, id, (1,), {"foo": 1}) 161 self.assertRaises(TypeError, apply) 162 self.assertRaises(TypeError, apply, id, 42) 163 self.assertRaises(TypeError, apply, id, (42,), 42) 164 165 def test_callable(self): 166 self.assertTrue(callable(len)) 167 self.assertFalse(callable("a")) 168 self.assertTrue(callable(callable)) 169 self.assertTrue(callable(lambda x, y: x + y)) 170 self.assertFalse(callable(__builtins__)) 171 def f(): pass 172 self.assertTrue(callable(f)) 173 174 class Classic: 175 def meth(self): pass 176 self.assertTrue(callable(Classic)) 177 c = Classic() 178 self.assertTrue(callable(c.meth)) 179 self.assertFalse(callable(c)) 180 181 class NewStyle(object): 182 def meth(self): pass 183 self.assertTrue(callable(NewStyle)) 184 n = NewStyle() 185 self.assertTrue(callable(n.meth)) 186 self.assertFalse(callable(n)) 187 188 # Classic and new-style classes evaluate __call__() differently 189 c.__call__ = None 190 self.assertTrue(callable(c)) 191 del c.__call__ 192 self.assertFalse(callable(c)) 193 n.__call__ = None 194 self.assertFalse(callable(n)) 195 del n.__call__ 196 self.assertFalse(callable(n)) 197 198 class N2(object): 199 def __call__(self): pass 200 n2 = N2() 201 self.assertTrue(callable(n2)) 202 class N3(N2): pass 203 n3 = N3() 204 self.assertTrue(callable(n3)) 205 206 def test_chr(self): 207 self.assertEqual(chr(32), ' ') 208 self.assertEqual(chr(65), 'A') 209 self.assertEqual(chr(97), 'a') 210 self.assertEqual(chr(0xff), '\xff') 211 self.assertRaises(ValueError, chr, 256) 212 self.assertRaises(TypeError, chr) 213 214 def test_cmp(self): 215 self.assertEqual(cmp(-1, 1), -1) 216 self.assertEqual(cmp(1, -1), 1) 217 self.assertEqual(cmp(1, 1), 0) 218 # verify that circular objects are not handled 219 a = []; a.append(a) 220 b = []; b.append(b) 221 from UserList import UserList 222 c = UserList(); c.append(c) 223 self.assertRaises(RuntimeError, cmp, a, b) 224 self.assertRaises(RuntimeError, cmp, b, c) 225 self.assertRaises(RuntimeError, cmp, c, a) 226 self.assertRaises(RuntimeError, cmp, a, c) 227 # okay, now break the cycles 228 a.pop(); b.pop(); c.pop() 229 self.assertRaises(TypeError, cmp) 230 231 def test_coerce(self): 232 self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) 233 self.assertEqual(coerce(1, 1L), (1L, 1L)) 234 self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1))) 235 self.assertRaises(TypeError, coerce) 236 class BadNumber: 237 def __coerce__(self, other): 238 raise ValueError 239 self.assertRaises(ValueError, coerce, 42, BadNumber()) 240 self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000)) 241 242 def test_compile(self): 243 compile('print 1\n', '', 'exec') 244 bom = '\xef\xbb\xbf' 245 compile(bom + 'print 1\n', '', 'exec') 246 compile(source='pass', filename='?', mode='exec') 247 compile(dont_inherit=0, filename='tmp', source='0', mode='eval') 248 compile('pass', '?', dont_inherit=1, mode='exec') 249 self.assertRaises(TypeError, compile) 250 self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode') 251 self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff) 252 self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') 253 self.assertRaises(TypeError, compile, 'pass', '?', 'exec', 254 mode='eval', source='0', filename='tmp') 255 if have_unicode: 256 compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec') 257 self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec') 258 self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad') 259 260 261 def test_delattr(self): 262 import sys 263 sys.spam = 1 264 delattr(sys, 'spam') 265 self.assertRaises(TypeError, delattr) 266 267 def test_dir(self): 268 # dir(wrong number of arguments) 269 self.assertRaises(TypeError, dir, 42, 42) 270 271 # dir() - local scope 272 local_var = 1 273 self.assertIn('local_var', dir()) 274 275 # dir(module) 276 import sys 277 self.assertIn('exit', dir(sys)) 278 279 # dir(module_with_invalid__dict__) 280 import types 281 class Foo(types.ModuleType): 282 __dict__ = 8 283 f = Foo("foo") 284 self.assertRaises(TypeError, dir, f) 285 286 # dir(type) 287 self.assertIn("strip", dir(str)) 288 self.assertNotIn("__mro__", dir(str)) 289 290 # dir(obj) 291 class Foo(object): 292 def __init__(self): 293 self.x = 7 294 self.y = 8 295 self.z = 9 296 f = Foo() 297 self.assertIn("y", dir(f)) 298 299 # dir(obj_no__dict__) 300 class Foo(object): 301 __slots__ = [] 302 f = Foo() 303 self.assertIn("__repr__", dir(f)) 304 305 # dir(obj_no__class__with__dict__) 306 # (an ugly trick to cause getattr(f, "__class__") to fail) 307 class Foo(object): 308 __slots__ = ["__class__", "__dict__"] 309 def __init__(self): 310 self.bar = "wow" 311 f = Foo() 312 self.assertNotIn("__repr__", dir(f)) 313 self.assertIn("bar", dir(f)) 314 315 # dir(obj_using __dir__) 316 class Foo(object): 317 def __dir__(self): 318 return ["kan", "ga", "roo"] 319 f = Foo() 320 self.assertTrue(dir(f) == ["ga", "kan", "roo"]) 321 322 # dir(obj__dir__not_list) 323 class Foo(object): 324 def __dir__(self): 325 return 7 326 f = Foo() 327 self.assertRaises(TypeError, dir, f) 328 329 def test_divmod(self): 330 self.assertEqual(divmod(12, 7), (1, 5)) 331 self.assertEqual(divmod(-12, 7), (-2, 2)) 332 self.assertEqual(divmod(12, -7), (-2, -2)) 333 self.assertEqual(divmod(-12, -7), (1, -5)) 334 335 self.assertEqual(divmod(12L, 7L), (1L, 5L)) 336 self.assertEqual(divmod(-12L, 7L), (-2L, 2L)) 337 self.assertEqual(divmod(12L, -7L), (-2L, -2L)) 338 self.assertEqual(divmod(-12L, -7L), (1L, -5L)) 339 340 self.assertEqual(divmod(12, 7L), (1, 5L)) 341 self.assertEqual(divmod(-12, 7L), (-2, 2L)) 342 self.assertEqual(divmod(12L, -7), (-2L, -2)) 343 self.assertEqual(divmod(-12L, -7), (1L, -5)) 344 345 self.assertEqual(divmod(-sys.maxint-1, -1), 346 (sys.maxint+1, 0)) 347 348 self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) 349 self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) 350 self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) 351 self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) 352 353 self.assertRaises(TypeError, divmod) 354 355 def test_eval(self): 356 self.assertEqual(eval('1+1'), 2) 357 self.assertEqual(eval(' 1+1\n'), 2) 358 globals = {'a': 1, 'b': 2} 359 locals = {'b': 200, 'c': 300} 360 self.assertEqual(eval('a', globals) , 1) 361 self.assertEqual(eval('a', globals, locals), 1) 362 self.assertEqual(eval('b', globals, locals), 200) 363 self.assertEqual(eval('c', globals, locals), 300) 364 if have_unicode: 365 self.assertEqual(eval(unicode('1+1')), 2) 366 self.assertEqual(eval(unicode(' 1+1\n')), 2) 367 globals = {'a': 1, 'b': 2} 368 locals = {'b': 200, 'c': 300} 369 if have_unicode: 370 self.assertEqual(eval(unicode('a'), globals), 1) 371 self.assertEqual(eval(unicode('a'), globals, locals), 1) 372 self.assertEqual(eval(unicode('b'), globals, locals), 200) 373 self.assertEqual(eval(unicode('c'), globals, locals), 300) 374 bom = '\xef\xbb\xbf' 375 self.assertEqual(eval(bom + 'a', globals, locals), 1) 376 self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals), 377 unicode('\xc3\xa5', 'utf8')) 378 self.assertRaises(TypeError, eval) 379 self.assertRaises(TypeError, eval, ()) 380 381 def test_general_eval(self): 382 # Tests that general mappings can be used for the locals argument 383 384 class M: 385 "Test mapping interface versus possible calls from eval()." 386 def __getitem__(self, key): 387 if key == 'a': 388 return 12 389 raise KeyError 390 def keys(self): 391 return list('xyz') 392 393 m = M() 394 g = globals() 395 self.assertEqual(eval('a', g, m), 12) 396 self.assertRaises(NameError, eval, 'b', g, m) 397 self.assertEqual(eval('dir()', g, m), list('xyz')) 398 self.assertEqual(eval('globals()', g, m), g) 399 self.assertEqual(eval('locals()', g, m), m) 400 self.assertRaises(TypeError, eval, 'a', m) 401 class A: 402 "Non-mapping" 403 pass 404 m = A() 405 self.assertRaises(TypeError, eval, 'a', g, m) 406 407 # Verify that dict subclasses work as well 408 class D(dict): 409 def __getitem__(self, key): 410 if key == 'a': 411 return 12 412 return dict.__getitem__(self, key) 413 def keys(self): 414 return list('xyz') 415 416 d = D() 417 self.assertEqual(eval('a', g, d), 12) 418 self.assertRaises(NameError, eval, 'b', g, d) 419 self.assertEqual(eval('dir()', g, d), list('xyz')) 420 self.assertEqual(eval('globals()', g, d), g) 421 self.assertEqual(eval('locals()', g, d), d) 422 423 # Verify locals stores (used by list comps) 424 eval('[locals() for i in (2,3)]', g, d) 425 eval('[locals() for i in (2,3)]', g, UserDict.UserDict()) 426 427 class SpreadSheet: 428 "Sample application showing nested, calculated lookups." 429 _cells = {} 430 def __setitem__(self, key, formula): 431 self._cells[key] = formula 432 def __getitem__(self, key): 433 return eval(self._cells[key], globals(), self) 434 435 ss = SpreadSheet() 436 ss['a1'] = '5' 437 ss['a2'] = 'a1*6' 438 ss['a3'] = 'a2*7' 439 self.assertEqual(ss['a3'], 210) 440 441 # Verify that dir() catches a non-list returned by eval 442 # SF bug #1004669 443 class C: 444 def __getitem__(self, item): 445 raise KeyError(item) 446 def keys(self): 447 return 'a' 448 self.assertRaises(TypeError, eval, 'dir()', globals(), C()) 449 450 def test_filter(self): 451 self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld') 452 self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9]) 453 self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2]) 454 self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81]) 455 self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81]) 456 def identity(item): 457 return 1 458 filter(identity, Squares(5)) 459 self.assertRaises(TypeError, filter) 460 class BadSeq(object): 461 def __getitem__(self, index): 462 if index<4: 463 return 42 464 raise ValueError 465 self.assertRaises(ValueError, filter, lambda x: x, BadSeq()) 466 def badfunc(): 467 pass 468 self.assertRaises(TypeError, filter, badfunc, range(5)) 469 470 # test bltinmodule.c::filtertuple() 471 self.assertEqual(filter(None, (1, 2)), (1, 2)) 472 self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4)) 473 self.assertRaises(TypeError, filter, 42, (1, 2)) 474 475 # test bltinmodule.c::filterstring() 476 self.assertEqual(filter(None, "12"), "12") 477 self.assertEqual(filter(lambda x: x>="3", "1234"), "34") 478 self.assertRaises(TypeError, filter, 42, "12") 479 class badstr(str): 480 def __getitem__(self, index): 481 raise ValueError 482 self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234")) 483 484 class badstr2(str): 485 def __getitem__(self, index): 486 return 42 487 self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234")) 488 489 class weirdstr(str): 490 def __getitem__(self, index): 491 return weirdstr(2*str.__getitem__(self, index)) 492 self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344") 493 494 class shiftstr(str): 495 def __getitem__(self, index): 496 return chr(ord(str.__getitem__(self, index))+1) 497 self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345") 498 499 if have_unicode: 500 # test bltinmodule.c::filterunicode() 501 self.assertEqual(filter(None, unicode("12")), unicode("12")) 502 self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34")) 503 self.assertRaises(TypeError, filter, 42, unicode("12")) 504 self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234"))) 505 506 class badunicode(unicode): 507 def __getitem__(self, index): 508 return 42 509 self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234")) 510 511 class weirdunicode(unicode): 512 def __getitem__(self, index): 513 return weirdunicode(2*unicode.__getitem__(self, index)) 514 self.assertEqual( 515 filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344")) 516 517 class shiftunicode(unicode): 518 def __getitem__(self, index): 519 return unichr(ord(unicode.__getitem__(self, index))+1) 520 self.assertEqual( 521 filter(lambda x: x>=unicode("3"), shiftunicode("1234")), 522 unicode("345") 523 ) 524 525 def test_filter_subclasses(self): 526 # test that filter() never returns tuple, str or unicode subclasses 527 # and that the result always goes through __getitem__ 528 funcs = (None, bool, lambda x: True) 529 class tuple2(tuple): 530 def __getitem__(self, index): 531 return 2*tuple.__getitem__(self, index) 532 class str2(str): 533 def __getitem__(self, index): 534 return 2*str.__getitem__(self, index) 535 inputs = { 536 tuple2: {(): (), (1, 2, 3): (2, 4, 6)}, 537 str2: {"": "", "123": "112233"} 538 } 539 if have_unicode: 540 class unicode2(unicode): 541 def __getitem__(self, index): 542 return 2*unicode.__getitem__(self, index) 543 inputs[unicode2] = { 544 unicode(): unicode(), 545 unicode("123"): unicode("112233") 546 } 547 548 for (cls, inps) in inputs.iteritems(): 549 for (inp, exp) in inps.iteritems(): 550 # make sure the output goes through __getitem__ 551 # even if func is None 552 self.assertEqual( 553 filter(funcs[0], cls(inp)), 554 filter(funcs[1], cls(inp)) 555 ) 556 for func in funcs: 557 outp = filter(func, cls(inp)) 558 self.assertEqual(outp, exp) 559 self.assertTrue(not isinstance(outp, cls)) 560 561 def test_getattr(self): 562 import sys 563 self.assertTrue(getattr(sys, 'stdout') is sys.stdout) 564 self.assertRaises(TypeError, getattr, sys, 1) 565 self.assertRaises(TypeError, getattr, sys, 1, "foo") 566 self.assertRaises(TypeError, getattr) 567 if have_unicode: 568 self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode)) 569 570 def test_hasattr(self): 571 import sys 572 self.assertTrue(hasattr(sys, 'stdout')) 573 self.assertRaises(TypeError, hasattr, sys, 1) 574 self.assertRaises(TypeError, hasattr) 575 if have_unicode: 576 self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode)) 577 578 # Check that hasattr allows SystemExit and KeyboardInterrupts by 579 class A: 580 def __getattr__(self, what): 581 raise KeyboardInterrupt 582 self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") 583 class B: 584 def __getattr__(self, what): 585 raise SystemExit 586 self.assertRaises(SystemExit, hasattr, B(), "b") 587 588 def test_hash(self): 589 hash(None) 590 self.assertEqual(hash(1), hash(1L)) 591 self.assertEqual(hash(1), hash(1.0)) 592 hash('spam') 593 if have_unicode: 594 self.assertEqual(hash('spam'), hash(unicode('spam'))) 595 hash((0,1,2,3)) 596 def f(): pass 597 self.assertRaises(TypeError, hash, []) 598 self.assertRaises(TypeError, hash, {}) 599 # Bug 1536021: Allow hash to return long objects 600 class X: 601 def __hash__(self): 602 return 2**100 603 self.assertEqual(type(hash(X())), int) 604 class Y(object): 605 def __hash__(self): 606 return 2**100 607 self.assertEqual(type(hash(Y())), int) 608 class Z(long): 609 def __hash__(self): 610 return self 611 self.assertEqual(hash(Z(42)), hash(42L)) 612 613 def test_hex(self): 614 self.assertEqual(hex(16), '0x10') 615 self.assertEqual(hex(16L), '0x10L') 616 self.assertEqual(hex(-16), '-0x10') 617 self.assertEqual(hex(-16L), '-0x10L') 618 self.assertRaises(TypeError, hex, {}) 619 620 def test_id(self): 621 id(None) 622 id(1) 623 id(1L) 624 id(1.0) 625 id('spam') 626 id((0,1,2,3)) 627 id([0,1,2,3]) 628 id({'spam': 1, 'eggs': 2, 'ham': 3}) 629 630 # Test input() later, together with raw_input 631 632 # test_int(): see test_int.py for int() tests. 633 634 def test_intern(self): 635 self.assertRaises(TypeError, intern) 636 # This fails if the test is run twice with a constant string, 637 # therefore append the run counter 638 s = "never interned before " + str(numruns) 639 self.assertTrue(intern(s) is s) 640 s2 = s.swapcase().swapcase() 641 self.assertTrue(intern(s2) is s) 642 643 # Subclasses of string can't be interned, because they 644 # provide too much opportunity for insane things to happen. 645 # We don't want them in the interned dict and if they aren't 646 # actually interned, we don't want to create the appearance 647 # that they are by allowing intern() to succeed. 648 class S(str): 649 def __hash__(self): 650 return 123 651 652 self.assertRaises(TypeError, intern, S("abc")) 653 654 # It's still safe to pass these strings to routines that 655 # call intern internally, e.g. PyObject_SetAttr(). 656 s = S("abc") 657 setattr(s, s, s) 658 self.assertEqual(getattr(s, s), s) 659 660 def test_iter(self): 661 self.assertRaises(TypeError, iter) 662 self.assertRaises(TypeError, iter, 42, 42) 663 lists = [("1", "2"), ["1", "2"], "12"] 664 if have_unicode: 665 lists.append(unicode("12")) 666 for l in lists: 667 i = iter(l) 668 self.assertEqual(i.next(), '1') 669 self.assertEqual(i.next(), '2') 670 self.assertRaises(StopIteration, i.next) 671 672 def test_isinstance(self): 673 class C: 674 pass 675 class D(C): 676 pass 677 class E: 678 pass 679 c = C() 680 d = D() 681 e = E() 682 self.assertTrue(isinstance(c, C)) 683 self.assertTrue(isinstance(d, C)) 684 self.assertTrue(not isinstance(e, C)) 685 self.assertTrue(not isinstance(c, D)) 686 self.assertTrue(not isinstance('foo', E)) 687 self.assertRaises(TypeError, isinstance, E, 'foo') 688 self.assertRaises(TypeError, isinstance) 689 690 def test_issubclass(self): 691 class C: 692 pass 693 class D(C): 694 pass 695 class E: 696 pass 697 c = C() 698 d = D() 699 e = E() 700 self.assertTrue(issubclass(D, C)) 701 self.assertTrue(issubclass(C, C)) 702 self.assertTrue(not issubclass(C, D)) 703 self.assertRaises(TypeError, issubclass, 'foo', E) 704 self.assertRaises(TypeError, issubclass, E, 'foo') 705 self.assertRaises(TypeError, issubclass) 706 707 def test_len(self): 708 self.assertEqual(len('123'), 3) 709 self.assertEqual(len(()), 0) 710 self.assertEqual(len((1, 2, 3, 4)), 4) 711 self.assertEqual(len([1, 2, 3, 4]), 4) 712 self.assertEqual(len({}), 0) 713 self.assertEqual(len({'a':1, 'b': 2}), 2) 714 class BadSeq: 715 def __len__(self): 716 raise ValueError 717 self.assertRaises(ValueError, len, BadSeq()) 718 self.assertRaises(TypeError, len, 2) 719 class ClassicStyle: pass 720 class NewStyle(object): pass 721 self.assertRaises(AttributeError, len, ClassicStyle()) 722 self.assertRaises(TypeError, len, NewStyle()) 723 724 def test_map(self): 725 self.assertEqual( 726 map(None, 'hello world'), 727 ['h','e','l','l','o',' ','w','o','r','l','d'] 728 ) 729 self.assertEqual( 730 map(None, 'abcd', 'efg'), 731 [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)] 732 ) 733 self.assertEqual( 734 map(None, range(10)), 735 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 736 ) 737 self.assertEqual( 738 map(lambda x: x*x, range(1,4)), 739 [1, 4, 9] 740 ) 741 try: 742 from math import sqrt 743 except ImportError: 744 def sqrt(x): 745 return pow(x, 0.5) 746 self.assertEqual( 747 map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]), 748 [[4.0, 2.0], [9.0, 3.0]] 749 ) 750 self.assertEqual( 751 map(lambda x, y: x+y, [1,3,2], [9,1,4]), 752 [10, 4, 6] 753 ) 754 755 def plus(*v): 756 accu = 0 757 for i in v: accu = accu + i 758 return accu 759 self.assertEqual( 760 map(plus, [1, 3, 7]), 761 [1, 3, 7] 762 ) 763 self.assertEqual( 764 map(plus, [1, 3, 7], [4, 9, 2]), 765 [1+4, 3+9, 7+2] 766 ) 767 self.assertEqual( 768 map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]), 769 [1+4+1, 3+9+1, 7+2+0] 770 ) 771 self.assertEqual( 772 map(None, Squares(10)), 773 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 774 ) 775 self.assertEqual( 776 map(int, Squares(10)), 777 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 778 ) 779 self.assertEqual( 780 map(None, Squares(3), Squares(2)), 781 [(0,0), (1,1), (4,None)] 782 ) 783 self.assertEqual( 784 map(max, Squares(3), Squares(2)), 785 [0, 1, 4] 786 ) 787 self.assertRaises(TypeError, map) 788 self.assertRaises(TypeError, map, lambda x: x, 42) 789 self.assertEqual(map(None, [42]), [42]) 790 class BadSeq: 791 def __getitem__(self, index): 792 raise ValueError 793 self.assertRaises(ValueError, map, lambda x: x, BadSeq()) 794 def badfunc(x): 795 raise RuntimeError 796 self.assertRaises(RuntimeError, map, badfunc, range(5)) 797 798 def test_max(self): 799 self.assertEqual(max('123123'), '3') 800 self.assertEqual(max(1, 2, 3), 3) 801 self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3) 802 self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3) 803 804 self.assertEqual(max(1, 2L, 3.0), 3.0) 805 self.assertEqual(max(1L, 2.0, 3), 3) 806 self.assertEqual(max(1.0, 2, 3L), 3L) 807 808 for stmt in ( 809 "max(key=int)", # no args 810 "max(1, key=int)", # single arg not iterable 811 "max(1, 2, keystone=int)", # wrong keyword 812 "max(1, 2, key=int, abc=int)", # two many keywords 813 "max(1, 2, key=1)", # keyfunc is not callable 814 ): 815 try: 816 exec(stmt) in globals() 817 except TypeError: 818 pass 819 else: 820 self.fail(stmt) 821 822 self.assertEqual(max((1,), key=neg), 1) # one elem iterable 823 self.assertEqual(max((1,2), key=neg), 1) # two elem iterable 824 self.assertEqual(max(1, 2, key=neg), 1) # two elems 825 826 data = [random.randrange(200) for i in range(100)] 827 keys = dict((elem, random.randrange(50)) for elem in data) 828 f = keys.__getitem__ 829 self.assertEqual(max(data, key=f), 830 sorted(reversed(data), key=f)[-1]) 831 832 def test_min(self): 833 self.assertEqual(min('123123'), '1') 834 self.assertEqual(min(1, 2, 3), 1) 835 self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1) 836 self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1) 837 838 self.assertEqual(min(1, 2L, 3.0), 1) 839 self.assertEqual(min(1L, 2.0, 3), 1L) 840 self.assertEqual(min(1.0, 2, 3L), 1.0) 841 842 self.assertRaises(TypeError, min) 843 self.assertRaises(TypeError, min, 42) 844 self.assertRaises(ValueError, min, ()) 845 class BadSeq: 846 def __getitem__(self, index): 847 raise ValueError 848 self.assertRaises(ValueError, min, BadSeq()) 849 class BadNumber: 850 def __cmp__(self, other): 851 raise ValueError 852 self.assertRaises(ValueError, min, (42, BadNumber())) 853 854 for stmt in ( 855 "min(key=int)", # no args 856 "min(1, key=int)", # single arg not iterable 857 "min(1, 2, keystone=int)", # wrong keyword 858 "min(1, 2, key=int, abc=int)", # two many keywords 859 "min(1, 2, key=1)", # keyfunc is not callable 860 ): 861 try: 862 exec(stmt) in globals() 863 except TypeError: 864 pass 865 else: 866 self.fail(stmt) 867 868 self.assertEqual(min((1,), key=neg), 1) # one elem iterable 869 self.assertEqual(min((1,2), key=neg), 2) # two elem iterable 870 self.assertEqual(min(1, 2, key=neg), 2) # two elems 871 872 data = [random.randrange(200) for i in range(100)] 873 keys = dict((elem, random.randrange(50)) for elem in data) 874 f = keys.__getitem__ 875 self.assertEqual(min(data, key=f), 876 sorted(data, key=f)[0]) 877 878 def test_next(self): 879 it = iter(range(2)) 880 self.assertEqual(next(it), 0) 881 self.assertEqual(next(it), 1) 882 self.assertRaises(StopIteration, next, it) 883 self.assertRaises(StopIteration, next, it) 884 self.assertEqual(next(it, 42), 42) 885 886 class Iter(object): 887 def __iter__(self): 888 return self 889 def next(self): 890 raise StopIteration 891 892 it = iter(Iter()) 893 self.assertEqual(next(it, 42), 42) 894 self.assertRaises(StopIteration, next, it) 895 896 def gen(): 897 yield 1 898 return 899 900 it = gen() 901 self.assertEqual(next(it), 1) 902 self.assertRaises(StopIteration, next, it) 903 self.assertEqual(next(it, 42), 42) 904 905 def test_oct(self): 906 self.assertEqual(oct(100), '0144') 907 self.assertEqual(oct(100L), '0144L') 908 self.assertEqual(oct(-100), '-0144') 909 self.assertEqual(oct(-100L), '-0144L') 910 self.assertRaises(TypeError, oct, ()) 911 912 def write_testfile(self): 913 # NB the first 4 lines are also used to test input and raw_input, below 914 fp = open(TESTFN, 'w') 915 try: 916 fp.write('1+1\n') 917 fp.write('1+1\n') 918 fp.write('The quick brown fox jumps over the lazy dog') 919 fp.write('.\n') 920 fp.write('Dear John\n') 921 fp.write('XXX'*100) 922 fp.write('YYY'*100) 923 finally: 924 fp.close() 925 926 def test_open(self): 927 self.write_testfile() 928 fp = open(TESTFN, 'r') 929 try: 930 self.assertEqual(fp.readline(4), '1+1\n') 931 self.assertEqual(fp.readline(4), '1+1\n') 932 self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n') 933 self.assertEqual(fp.readline(4), 'Dear') 934 self.assertEqual(fp.readline(100), ' John\n') 935 self.assertEqual(fp.read(300), 'XXX'*100) 936 self.assertEqual(fp.read(1000), 'YYY'*100) 937 finally: 938 fp.close() 939 unlink(TESTFN) 940 941 def test_ord(self): 942 self.assertEqual(ord(' '), 32) 943 self.assertEqual(ord('A'), 65) 944 self.assertEqual(ord('a'), 97) 945 if have_unicode: 946 self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode) 947 self.assertRaises(TypeError, ord, 42) 948 if have_unicode: 949 self.assertRaises(TypeError, ord, unicode("12")) 950 951 def test_pow(self): 952 self.assertEqual(pow(0,0), 1) 953 self.assertEqual(pow(0,1), 0) 954 self.assertEqual(pow(1,0), 1) 955 self.assertEqual(pow(1,1), 1) 956 957 self.assertEqual(pow(2,0), 1) 958 self.assertEqual(pow(2,10), 1024) 959 self.assertEqual(pow(2,20), 1024*1024) 960 self.assertEqual(pow(2,30), 1024*1024*1024) 961 962 self.assertEqual(pow(-2,0), 1) 963 self.assertEqual(pow(-2,1), -2) 964 self.assertEqual(pow(-2,2), 4) 965 self.assertEqual(pow(-2,3), -8) 966 967 self.assertEqual(pow(0L,0), 1) 968 self.assertEqual(pow(0L,1), 0) 969 self.assertEqual(pow(1L,0), 1) 970 self.assertEqual(pow(1L,1), 1) 971 972 self.assertEqual(pow(2L,0), 1) 973 self.assertEqual(pow(2L,10), 1024) 974 self.assertEqual(pow(2L,20), 1024*1024) 975 self.assertEqual(pow(2L,30), 1024*1024*1024) 976 977 self.assertEqual(pow(-2L,0), 1) 978 self.assertEqual(pow(-2L,1), -2) 979 self.assertEqual(pow(-2L,2), 4) 980 self.assertEqual(pow(-2L,3), -8) 981 982 self.assertAlmostEqual(pow(0.,0), 1.) 983 self.assertAlmostEqual(pow(0.,1), 0.) 984 self.assertAlmostEqual(pow(1.,0), 1.) 985 self.assertAlmostEqual(pow(1.,1), 1.) 986 987 self.assertAlmostEqual(pow(2.,0), 1.) 988 self.assertAlmostEqual(pow(2.,10), 1024.) 989 self.assertAlmostEqual(pow(2.,20), 1024.*1024.) 990 self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.) 991 992 self.assertAlmostEqual(pow(-2.,0), 1.) 993 self.assertAlmostEqual(pow(-2.,1), -2.) 994 self.assertAlmostEqual(pow(-2.,2), 4.) 995 self.assertAlmostEqual(pow(-2.,3), -8.) 996 997 for x in 2, 2L, 2.0: 998 for y in 10, 10L, 10.0: 999 for z in 1000, 1000L, 1000.0: 1000 if isinstance(x, float) or \ 1001 isinstance(y, float) or \ 1002 isinstance(z, float): 1003 self.assertRaises(TypeError, pow, x, y, z) 1004 else: 1005 self.assertAlmostEqual(pow(x, y, z), 24.0) 1006 1007 self.assertRaises(TypeError, pow, -1, -2, 3) 1008 self.assertRaises(ValueError, pow, 1, 2, 0) 1009 self.assertRaises(TypeError, pow, -1L, -2L, 3L) 1010 self.assertRaises(ValueError, pow, 1L, 2L, 0L) 1011 # Will return complex in 3.0: 1012 self.assertRaises(ValueError, pow, -342.43, 0.234) 1013 1014 self.assertRaises(TypeError, pow) 1015 1016 def test_range(self): 1017 self.assertEqual(range(3), [0, 1, 2]) 1018 self.assertEqual(range(1, 5), [1, 2, 3, 4]) 1019 self.assertEqual(range(0), []) 1020 self.assertEqual(range(-3), []) 1021 self.assertEqual(range(1, 10, 3), [1, 4, 7]) 1022 self.assertEqual(range(5, -5, -3), [5, 2, -1, -4]) 1023 1024 # Now test range() with longs 1025 self.assertEqual(range(-2**100), []) 1026 self.assertEqual(range(0, -2**100), []) 1027 self.assertEqual(range(0, 2**100, -1), []) 1028 self.assertEqual(range(0, 2**100, -1), []) 1029 1030 a = long(10 * sys.maxint) 1031 b = long(100 * sys.maxint) 1032 c = long(50 * sys.maxint) 1033 1034 self.assertEqual(range(a, a+2), [a, a+1]) 1035 self.assertEqual(range(a+2, a, -1L), [a+2, a+1]) 1036 self.assertEqual(range(a+4, a, -2), [a+4, a+2]) 1037 1038 seq = range(a, b, c) 1039 self.assertIn(a, seq) 1040 self.assertNotIn(b, seq) 1041 self.assertEqual(len(seq), 2) 1042 1043 seq = range(b, a, -c) 1044 self.assertIn(b, seq) 1045 self.assertNotIn(a, seq) 1046 self.assertEqual(len(seq), 2) 1047 1048 seq = range(-a, -b, -c) 1049 self.assertIn(-a, seq) 1050 self.assertNotIn(-b, seq) 1051 self.assertEqual(len(seq), 2) 1052 1053 self.assertRaises(TypeError, range) 1054 self.assertRaises(TypeError, range, 1, 2, 3, 4) 1055 self.assertRaises(ValueError, range, 1, 2, 0) 1056 self.assertRaises(ValueError, range, a, a + 1, long(0)) 1057 1058 class badzero(int): 1059 def __cmp__(self, other): 1060 raise RuntimeError 1061 __hash__ = None # Invalid cmp makes this unhashable 1062 self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) 1063 1064 # Reject floats. 1065 self.assertRaises(TypeError, range, 1., 1., 1.) 1066 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) 1067 1068 self.assertRaises(TypeError, range, 0, "spam") 1069 self.assertRaises(TypeError, range, 0, 42, "spam") 1070 1071 self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) 1072 self.assertRaises(OverflowError, range, 0, 2*sys.maxint) 1073 1074 bignum = 2*sys.maxint 1075 smallnum = 42 1076 # Old-style user-defined class with __int__ method 1077 class I0: 1078 def __init__(self, n): 1079 self.n = int(n) 1080 def __int__(self): 1081 return self.n 1082 self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) 1083 self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) 1084 1085 # New-style user-defined class with __int__ method 1086 class I1(object): 1087 def __init__(self, n): 1088 self.n = int(n) 1089 def __int__(self): 1090 return self.n 1091 self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) 1092 self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) 1093 1094 # New-style user-defined class with failing __int__ method 1095 class IX(object): 1096 def __int__(self): 1097 raise RuntimeError 1098 self.assertRaises(RuntimeError, range, IX()) 1099 1100 # New-style user-defined class with invalid __int__ method 1101 class IN(object): 1102 def __int__(self): 1103 return "not a number" 1104 self.assertRaises(TypeError, range, IN()) 1105 1106 # Exercise various combinations of bad arguments, to check 1107 # refcounting logic 1108 self.assertRaises(TypeError, range, 0.0) 1109 1110 self.assertRaises(TypeError, range, 0, 0.0) 1111 self.assertRaises(TypeError, range, 0.0, 0) 1112 self.assertRaises(TypeError, range, 0.0, 0.0) 1113 1114 self.assertRaises(TypeError, range, 0, 0, 1.0) 1115 self.assertRaises(TypeError, range, 0, 0.0, 1) 1116 self.assertRaises(TypeError, range, 0, 0.0, 1.0) 1117 self.assertRaises(TypeError, range, 0.0, 0, 1) 1118 self.assertRaises(TypeError, range, 0.0, 0, 1.0) 1119 self.assertRaises(TypeError, range, 0.0, 0.0, 1) 1120 self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) 1121 1122 1123 1124 def test_input_and_raw_input(self): 1125 self.write_testfile() 1126 fp = open(TESTFN, 'r') 1127 savestdin = sys.stdin 1128 savestdout = sys.stdout # Eats the echo 1129 try: 1130 sys.stdin = fp 1131 sys.stdout = BitBucket() 1132 self.assertEqual(input(), 2) 1133 self.assertEqual(input('testing\n'), 2) 1134 self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.') 1135 self.assertEqual(raw_input('testing\n'), 'Dear John') 1136 1137 # SF 1535165: don't segfault on closed stdin 1138 # sys.stdout must be a regular file for triggering 1139 sys.stdout = savestdout 1140 sys.stdin.close() 1141 self.assertRaises(ValueError, input) 1142 1143 sys.stdout = BitBucket() 1144 sys.stdin = cStringIO.StringIO("NULL\0") 1145 self.assertRaises(TypeError, input, 42, 42) 1146 sys.stdin = cStringIO.StringIO(" 'whitespace'") 1147 self.assertEqual(input(), 'whitespace') 1148 sys.stdin = cStringIO.StringIO() 1149 self.assertRaises(EOFError, input) 1150 1151 # SF 876178: make sure input() respect future options. 1152 sys.stdin = cStringIO.StringIO('1/2') 1153 sys.stdout = cStringIO.StringIO() 1154 exec compile('print input()', 'test_builtin_tmp', 'exec') 1155 sys.stdin.seek(0, 0) 1156 exec compile('from __future__ import division;print input()', 1157 'test_builtin_tmp', 'exec') 1158 sys.stdin.seek(0, 0) 1159 exec compile('print input()', 'test_builtin_tmp', 'exec') 1160 # The result we expect depends on whether new division semantics 1161 # are already in effect. 1162 if 1/2 == 0: 1163 # This test was compiled with old semantics. 1164 expected = ['0', '0.5', '0'] 1165 else: 1166 # This test was compiled with new semantics (e.g., -Qnew 1167 # was given on the command line. 1168 expected = ['0.5', '0.5', '0.5'] 1169 self.assertEqual(sys.stdout.getvalue().splitlines(), expected) 1170 1171 del sys.stdout 1172 self.assertRaises(RuntimeError, input, 'prompt') 1173 del sys.stdin 1174 self.assertRaises(RuntimeError, input, 'prompt') 1175 finally: 1176 sys.stdin = savestdin 1177 sys.stdout = savestdout 1178 fp.close() 1179 unlink(TESTFN) 1180 1181 def test_reduce(self): 1182 add = lambda x, y: x+y 1183 self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') 1184 self.assertEqual( 1185 reduce(add, [['a', 'c'], [], ['d', 'w']], []), 1186 ['a','c','d','w'] 1187 ) 1188 self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040) 1189 self.assertEqual( 1190 reduce(lambda x, y: x*y, range(2,21), 1L), 1191 2432902008176640000L 1192 ) 1193 self.assertEqual(reduce(add, Squares(10)), 285) 1194 self.assertEqual(reduce(add, Squares(10), 0), 285) 1195 self.assertEqual(reduce(add, Squares(0), 0), 0) 1196 self.assertRaises(TypeError, reduce) 1197 self.assertRaises(TypeError, reduce, 42) 1198 self.assertRaises(TypeError, reduce, 42, 42) 1199 self.assertRaises(TypeError, reduce, 42, 42, 42) 1200 self.assertRaises(TypeError, reduce, None, range(5)) 1201 self.assertRaises(TypeError, reduce, add, 42) 1202 self.assertEqual(reduce(42, "1"), "1") # func is never called with one item 1203 self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item 1204 self.assertRaises(TypeError, reduce, 42, (42, 42)) 1205 self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value 1206 self.assertRaises(TypeError, reduce, add, "") 1207 self.assertRaises(TypeError, reduce, add, ()) 1208 self.assertEqual(reduce(add, [], None), None) 1209 self.assertEqual(reduce(add, [], 42), 42) 1210 1211 class BadSeq: 1212 def __getitem__(self, index): 1213 raise ValueError 1214 self.assertRaises(ValueError, reduce, 42, BadSeq()) 1215 1216 def test_reload(self): 1217 import marshal 1218 reload(marshal) 1219 import string 1220 reload(string) 1221 ## import sys 1222 ## self.assertRaises(ImportError, reload, sys) 1223 1224 def test_repr(self): 1225 self.assertEqual(repr(''), '\'\'') 1226 self.assertEqual(repr(0), '0') 1227 self.assertEqual(repr(0L), '0L') 1228 self.assertEqual(repr(()), '()') 1229 self.assertEqual(repr([]), '[]') 1230 self.assertEqual(repr({}), '{}') 1231 a = [] 1232 a.append(a) 1233 self.assertEqual(repr(a), '[[...]]') 1234 a = {} 1235 a[0] = a 1236 self.assertEqual(repr(a), '{0: {...}}') 1237 1238 def test_round(self): 1239 self.assertEqual(round(0.0), 0.0) 1240 self.assertEqual(type(round(0.0)), float) # Will be int in 3.0. 1241 self.assertEqual(round(1.0), 1.0) 1242 self.assertEqual(round(10.0), 10.0) 1243 self.assertEqual(round(1000000000.0), 1000000000.0) 1244 self.assertEqual(round(1e20), 1e20) 1245 1246 self.assertEqual(round(-1.0), -1.0) 1247 self.assertEqual(round(-10.0), -10.0) 1248 self.assertEqual(round(-1000000000.0), -1000000000.0) 1249 self.assertEqual(round(-1e20), -1e20) 1250 1251 self.assertEqual(round(0.1), 0.0) 1252 self.assertEqual(round(1.1), 1.0) 1253 self.assertEqual(round(10.1), 10.0) 1254 self.assertEqual(round(1000000000.1), 1000000000.0) 1255 1256 self.assertEqual(round(-1.1), -1.0) 1257 self.assertEqual(round(-10.1), -10.0) 1258 self.assertEqual(round(-1000000000.1), -1000000000.0) 1259 1260 self.assertEqual(round(0.9), 1.0) 1261 self.assertEqual(round(9.9), 10.0) 1262 self.assertEqual(round(999999999.9), 1000000000.0) 1263 1264 self.assertEqual(round(-0.9), -1.0) 1265 self.assertEqual(round(-9.9), -10.0) 1266 self.assertEqual(round(-999999999.9), -1000000000.0) 1267 1268 self.assertEqual(round(-8.0, -1), -10.0) 1269 self.assertEqual(type(round(-8.0, -1)), float) 1270 1271 self.assertEqual(type(round(-8.0, 0)), float) 1272 self.assertEqual(type(round(-8.0, 1)), float) 1273 1274 # Check half rounding behaviour. 1275 self.assertEqual(round(5.5), 6) 1276 self.assertEqual(round(6.5), 7) 1277 self.assertEqual(round(-5.5), -6) 1278 self.assertEqual(round(-6.5), -7) 1279 1280 # Check behavior on ints 1281 self.assertEqual(round(0), 0) 1282 self.assertEqual(round(8), 8) 1283 self.assertEqual(round(-8), -8) 1284 self.assertEqual(type(round(0)), float) # Will be int in 3.0. 1285 self.assertEqual(type(round(-8, -1)), float) 1286 self.assertEqual(type(round(-8, 0)), float) 1287 self.assertEqual(type(round(-8, 1)), float) 1288 1289 # test new kwargs 1290 self.assertEqual(round(number=-8.0, ndigits=-1), -10.0) 1291 1292 self.assertRaises(TypeError, round) 1293 1294 # test generic rounding delegation for reals 1295 class TestRound(object): 1296 def __float__(self): 1297 return 23.0 1298 1299 class TestNoRound(object): 1300 pass 1301 1302 self.assertEqual(round(TestRound()), 23) 1303 1304 self.assertRaises(TypeError, round, 1, 2, 3) 1305 self.assertRaises(TypeError, round, TestNoRound()) 1306 1307 t = TestNoRound() 1308 t.__float__ = lambda *args: args 1309 self.assertRaises(TypeError, round, t) 1310 self.assertRaises(TypeError, round, t, 0) 1311 1312 # Some versions of glibc for alpha have a bug that affects 1313 # float -> integer rounding (floor, ceil, rint, round) for 1314 # values in the range [2**52, 2**53). See: 1315 # 1316 # http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350 1317 # 1318 # We skip this test on Linux/alpha if it would fail. 1319 linux_alpha = (platform.system().startswith('Linux') and 1320 platform.machine().startswith('alpha')) 1321 system_round_bug = round(5e15+1) != 5e15+1 1322 @unittest.skipIf(linux_alpha and system_round_bug, 1323 "test will fail; failure is probably due to a " 1324 "buggy system round function") 1325 def test_round_large(self): 1326 # Issue #1869: integral floats should remain unchanged 1327 self.assertEqual(round(5e15-1), 5e15-1) 1328 self.assertEqual(round(5e15), 5e15) 1329 self.assertEqual(round(5e15+1), 5e15+1) 1330 self.assertEqual(round(5e15+2), 5e15+2) 1331 self.assertEqual(round(5e15+3), 5e15+3) 1332 1333 def test_setattr(self): 1334 setattr(sys, 'spam', 1) 1335 self.assertEqual(sys.spam, 1) 1336 self.assertRaises(TypeError, setattr, sys, 1, 'spam') 1337 self.assertRaises(TypeError, setattr) 1338 1339 def test_sum(self): 1340 self.assertEqual(sum([]), 0) 1341 self.assertEqual(sum(range(2,8)), 27) 1342 self.assertEqual(sum(iter(range(2,8))), 27) 1343 self.assertEqual(sum(Squares(10)), 285) 1344 self.assertEqual(sum(iter(Squares(10))), 285) 1345 self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3]) 1346 1347 self.assertRaises(TypeError, sum) 1348 self.assertRaises(TypeError, sum, 42) 1349 self.assertRaises(TypeError, sum, ['a', 'b', 'c']) 1350 self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '') 1351 self.assertRaises(TypeError, sum, [[1], [2], [3]]) 1352 self.assertRaises(TypeError, sum, [{2:3}]) 1353 self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3}) 1354 1355 class BadSeq: 1356 def __getitem__(self, index): 1357 raise ValueError 1358 self.assertRaises(ValueError, sum, BadSeq()) 1359 1360 empty = [] 1361 sum(([x] for x in range(10)), empty) 1362 self.assertEqual(empty, []) 1363 1364 def test_type(self): 1365 self.assertEqual(type(''), type('123')) 1366 self.assertNotEqual(type(''), type(())) 1367 1368 def test_unichr(self): 1369 if have_unicode: 1370 self.assertEqual(unichr(32), unicode(' ')) 1371 self.assertEqual(unichr(65), unicode('A')) 1372 self.assertEqual(unichr(97), unicode('a')) 1373 self.assertEqual( 1374 unichr(sys.maxunicode), 1375 unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape') 1376 ) 1377 self.assertRaises(ValueError, unichr, sys.maxunicode+1) 1378 self.assertRaises(TypeError, unichr) 1379 self.assertRaises((OverflowError, ValueError), unichr, 2**32) 1380 1381 # We don't want self in vars(), so these are static methods 1382 1383 @staticmethod 1384 def get_vars_f0(): 1385 return vars() 1386 1387 @staticmethod 1388 def get_vars_f2(): 1389 BuiltinTest.get_vars_f0() 1390 a = 1 1391 b = 2 1392 return vars() 1393 1394 class C_get_vars(object): 1395 def getDict(self): 1396 return {'a':2} 1397 __dict__ = property(fget=getDict) 1398 1399 def test_vars(self): 1400 self.assertEqual(set(vars()), set(dir())) 1401 import sys 1402 self.assertEqual(set(vars(sys)), set(dir(sys))) 1403 self.assertEqual(self.get_vars_f0(), {}) 1404 self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2}) 1405 self.assertRaises(TypeError, vars, 42, 42) 1406 self.assertRaises(TypeError, vars, 42) 1407 self.assertEqual(vars(self.C_get_vars()), {'a':2}) 1408 1409 def test_zip(self): 1410 a = (1, 2, 3) 1411 b = (4, 5, 6) 1412 t = [(1, 4), (2, 5), (3, 6)] 1413 self.assertEqual(zip(a, b), t) 1414 b = [4, 5, 6] 1415 self.assertEqual(zip(a, b), t) 1416 b = (4, 5, 6, 7) 1417 self.assertEqual(zip(a, b), t) 1418 class I: 1419 def __getitem__(self, i): 1420 if i < 0 or i > 2: raise IndexError 1421 return i + 4 1422 self.assertEqual(zip(a, I()), t) 1423 self.assertEqual(zip(), []) 1424 self.assertEqual(zip(*[]), []) 1425 self.assertRaises(TypeError, zip, None) 1426 class G: 1427 pass 1428 self.assertRaises(TypeError, zip, a, G()) 1429 1430 # Make sure zip doesn't try to allocate a billion elements for the 1431 # result list when one of its arguments doesn't say how long it is. 1432 # A MemoryError is the most likely failure mode. 1433 class SequenceWithoutALength: 1434 def __getitem__(self, i): 1435 if i == 5: 1436 raise IndexError 1437 else: 1438 return i 1439 self.assertEqual( 1440 zip(SequenceWithoutALength(), xrange(2**30)), 1441 list(enumerate(range(5))) 1442 ) 1443 1444 class BadSeq: 1445 def __getitem__(self, i): 1446 if i == 5: 1447 raise ValueError 1448 else: 1449 return i 1450 self.assertRaises(ValueError, zip, BadSeq(), BadSeq()) 1451 1452 def test_format(self): 1453 # Test the basic machinery of the format() builtin. Don't test 1454 # the specifics of the various formatters 1455 self.assertEqual(format(3, ''), '3') 1456 1457 # Returns some classes to use for various tests. There's 1458 # an old-style version, and a new-style version 1459 def classes_new(): 1460 class A(object): 1461 def __init__(self, x): 1462 self.x = x 1463 def __format__(self, format_spec): 1464 return str(self.x) + format_spec 1465 class DerivedFromA(A): 1466 pass 1467 1468 class Simple(object): pass 1469 class DerivedFromSimple(Simple): 1470 def __init__(self, x): 1471 self.x = x 1472 def __format__(self, format_spec): 1473 return str(self.x) + format_spec 1474 class DerivedFromSimple2(DerivedFromSimple): pass 1475 return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 1476 1477 # In 3.0, classes_classic has the same meaning as classes_new 1478 def classes_classic(): 1479 class A: 1480 def __init__(self, x): 1481 self.x = x 1482 def __format__(self, format_spec): 1483 return str(self.x) + format_spec 1484 class DerivedFromA(A): 1485 pass 1486 1487 class Simple: pass 1488 class DerivedFromSimple(Simple): 1489 def __init__(self, x): 1490 self.x = x 1491 def __format__(self, format_spec): 1492 return str(self.x) + format_spec 1493 class DerivedFromSimple2(DerivedFromSimple): pass 1494 return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 1495 1496 def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): 1497 self.assertEqual(format(A(3), 'spec'), '3spec') 1498 self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') 1499 self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') 1500 self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), 1501 '10abcdef') 1502 1503 class_test(*classes_new()) 1504 class_test(*classes_classic()) 1505 1506 def empty_format_spec(value): 1507 # test that: 1508 # format(x, '') == str(x) 1509 # format(x) == str(x) 1510 self.assertEqual(format(value, ""), str(value)) 1511 self.assertEqual(format(value), str(value)) 1512 1513 # for builtin types, format(x, "") == str(x) 1514 empty_format_spec(17**13) 1515 empty_format_spec(1.0) 1516 empty_format_spec(3.1415e104) 1517 empty_format_spec(-3.1415e104) 1518 empty_format_spec(3.1415e-104) 1519 empty_format_spec(-3.1415e-104) 1520 empty_format_spec(object) 1521 empty_format_spec(None) 1522 1523 # TypeError because self.__format__ returns the wrong type 1524 class BadFormatResult: 1525 def __format__(self, format_spec): 1526 return 1.0 1527 self.assertRaises(TypeError, format, BadFormatResult(), "") 1528 1529 # TypeError because format_spec is not unicode or str 1530 self.assertRaises(TypeError, format, object(), 4) 1531 self.assertRaises(TypeError, format, object(), object()) 1532 1533 # tests for object.__format__ really belong elsewhere, but 1534 # there's no good place to put them 1535 x = object().__format__('') 1536 self.assertTrue(x.startswith('<object object at')) 1537 1538 # first argument to object.__format__ must be string 1539 self.assertRaises(TypeError, object().__format__, 3) 1540 self.assertRaises(TypeError, object().__format__, object()) 1541 self.assertRaises(TypeError, object().__format__, None) 1542 1543 # -------------------------------------------------------------------- 1544 # Issue #7994: object.__format__ with a non-empty format string is 1545 # pending deprecated 1546 def test_deprecated_format_string(obj, fmt_str, should_raise_warning): 1547 with warnings.catch_warnings(record=True) as w: 1548 warnings.simplefilter("always", PendingDeprecationWarning) 1549 format(obj, fmt_str) 1550 if should_raise_warning: 1551 self.assertEqual(len(w), 1) 1552 self.assertIsInstance(w[0].message, PendingDeprecationWarning) 1553 self.assertIn('object.__format__ with a non-empty format ' 1554 'string', str(w[0].message)) 1555 else: 1556 self.assertEqual(len(w), 0) 1557 1558 fmt_strs = ['', 's', u'', u's'] 1559 1560 class A: 1561 def __format__(self, fmt_str): 1562 return format('', fmt_str) 1563 1564 for fmt_str in fmt_strs: 1565 test_deprecated_format_string(A(), fmt_str, False) 1566 1567 class B: 1568 pass 1569 1570 class C(object): 1571 pass 1572 1573 for cls in [object, B, C]: 1574 for fmt_str in fmt_strs: 1575 test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) 1576 # -------------------------------------------------------------------- 1577 1578 # make sure we can take a subclass of str as a format spec 1579 class DerivedFromStr(str): pass 1580 self.assertEqual(format(0, DerivedFromStr('10')), ' 0') 1581 1582 def test_bin(self): 1583 self.assertEqual(bin(0), '0b0') 1584 self.assertEqual(bin(1), '0b1') 1585 self.assertEqual(bin(-1), '-0b1') 1586 self.assertEqual(bin(2**65), '0b1' + '0' * 65) 1587 self.assertEqual(bin(2**65-1), '0b' + '1' * 65) 1588 self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65) 1589 self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65) 1590 1591 def test_bytearray_translate(self): 1592 x = bytearray("abc") 1593 self.assertRaises(ValueError, x.translate, "1", 1) 1594 self.assertRaises(TypeError, x.translate, "1"*256, 1) 1595 1596class TestExecFile(unittest.TestCase): 1597 # Done outside of the method test_z to get the correct scope 1598 z = 0 1599 f = open(TESTFN, 'w') 1600 f.write('z = z+1\n') 1601 f.write('z = z*2\n') 1602 f.close() 1603 with check_py3k_warnings(("execfile.. not supported in 3.x", 1604 DeprecationWarning)): 1605 execfile(TESTFN) 1606 1607 def test_execfile(self): 1608 globals = {'a': 1, 'b': 2} 1609 locals = {'b': 200, 'c': 300} 1610 1611 self.assertEqual(self.__class__.z, 2) 1612 globals['z'] = 0 1613 execfile(TESTFN, globals) 1614 self.assertEqual(globals['z'], 2) 1615 locals['z'] = 0 1616 execfile(TESTFN, globals, locals) 1617 self.assertEqual(locals['z'], 2) 1618 1619 class M: 1620 "Test mapping interface versus possible calls from execfile()." 1621 def __init__(self): 1622 self.z = 10 1623 def __getitem__(self, key): 1624 if key == 'z': 1625 return self.z 1626 raise KeyError 1627 def __setitem__(self, key, value): 1628 if key == 'z': 1629 self.z = value 1630 return 1631 raise KeyError 1632 1633 locals = M() 1634 locals['z'] = 0 1635 execfile(TESTFN, globals, locals) 1636 self.assertEqual(locals['z'], 2) 1637 1638 unlink(TESTFN) 1639 self.assertRaises(TypeError, execfile) 1640 self.assertRaises(TypeError, execfile, TESTFN, {}, ()) 1641 import os 1642 self.assertRaises(IOError, execfile, os.curdir) 1643 self.assertRaises(IOError, execfile, "I_dont_exist") 1644 1645 1646class TestSorted(unittest.TestCase): 1647 1648 def test_basic(self): 1649 data = range(100) 1650 copy = data[:] 1651 random.shuffle(copy) 1652 self.assertEqual(data, sorted(copy)) 1653 self.assertNotEqual(data, copy) 1654 1655 data.reverse() 1656 random.shuffle(copy) 1657 self.assertEqual(data, sorted(copy, cmp=lambda x, y: cmp(y,x))) 1658 self.assertNotEqual(data, copy) 1659 random.shuffle(copy) 1660 self.assertEqual(data, sorted(copy, key=lambda x: -x)) 1661 self.assertNotEqual(data, copy) 1662 random.shuffle(copy) 1663 self.assertEqual(data, sorted(copy, reverse=1)) 1664 self.assertNotEqual(data, copy) 1665 1666 def test_inputtypes(self): 1667 s = 'abracadabra' 1668 types = [list, tuple] 1669 if have_unicode: 1670 types.insert(0, unicode) 1671 for T in types: 1672 self.assertEqual(sorted(s), sorted(T(s))) 1673 1674 s = ''.join(dict.fromkeys(s).keys()) # unique letters only 1675 types = [set, frozenset, list, tuple, dict.fromkeys] 1676 if have_unicode: 1677 types.insert(0, unicode) 1678 for T in types: 1679 self.assertEqual(sorted(s), sorted(T(s))) 1680 1681 def test_baddecorator(self): 1682 data = 'The quick Brown fox Jumped over The lazy Dog'.split() 1683 self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) 1684 1685 1686class TestType(unittest.TestCase): 1687 def test_new_type(self): 1688 A = type('A', (), {}) 1689 self.assertEqual(A.__name__, 'A') 1690 self.assertEqual(A.__module__, __name__) 1691 self.assertEqual(A.__bases__, (object,)) 1692 self.assertIs(A.__base__, object) 1693 x = A() 1694 self.assertIs(type(x), A) 1695 self.assertIs(x.__class__, A) 1696 1697 class B: 1698 def ham(self): 1699 return 'ham%d' % self 1700 C = type('C', (B, int), {'spam': lambda self: 'spam%s' % self}) 1701 self.assertEqual(C.__name__, 'C') 1702 self.assertEqual(C.__module__, __name__) 1703 self.assertEqual(C.__bases__, (B, int)) 1704 self.assertIs(C.__base__, int) 1705 self.assertIn('spam', C.__dict__) 1706 self.assertNotIn('ham', C.__dict__) 1707 x = C(42) 1708 self.assertEqual(x, 42) 1709 self.assertIs(type(x), C) 1710 self.assertIs(x.__class__, C) 1711 self.assertEqual(x.ham(), 'ham42') 1712 self.assertEqual(x.spam(), 'spam42') 1713 self.assertEqual(x.bit_length(), 6) 1714 1715 def test_type_new_keywords(self): 1716 class B: 1717 def ham(self): 1718 return 'ham%d' % self 1719 C = type.__new__(type, 1720 name='C', 1721 bases=(B, int), 1722 dict={'spam': lambda self: 'spam%s' % self}) 1723 self.assertEqual(C.__name__, 'C') 1724 self.assertEqual(C.__module__, __name__) 1725 self.assertEqual(C.__bases__, (B, int)) 1726 self.assertIs(C.__base__, int) 1727 self.assertIn('spam', C.__dict__) 1728 self.assertNotIn('ham', C.__dict__) 1729 1730 def test_type_name(self): 1731 for name in 'A', '\xc4', 'B.A', '42', '': 1732 A = type(name, (), {}) 1733 self.assertEqual(A.__name__, name) 1734 self.assertEqual(A.__module__, __name__) 1735 with self.assertRaises(ValueError): 1736 type('A\x00B', (), {}) 1737 with self.assertRaises(TypeError): 1738 type(u'A', (), {}) 1739 1740 C = type('C', (), {}) 1741 for name in 'A', '\xc4', 'B.A', '42', '': 1742 C.__name__ = name 1743 self.assertEqual(C.__name__, name) 1744 self.assertEqual(C.__module__, __name__) 1745 1746 A = type('C', (), {}) 1747 with self.assertRaises(ValueError): 1748 A.__name__ = 'A\x00B' 1749 self.assertEqual(A.__name__, 'C') 1750 with self.assertRaises(TypeError): 1751 A.__name__ = u'A' 1752 self.assertEqual(A.__name__, 'C') 1753 1754 def test_type_doc(self): 1755 tests = ('x', '\xc4', 'x\x00y', 42, None) 1756 if have_unicode: 1757 tests += (u'\xc4', u'x\x00y') 1758 for doc in tests: 1759 A = type('A', (), {'__doc__': doc}) 1760 self.assertEqual(A.__doc__, doc) 1761 1762 A = type('A', (), {}) 1763 self.assertEqual(A.__doc__, None) 1764 with self.assertRaises(AttributeError): 1765 A.__doc__ = 'x' 1766 1767 def test_bad_args(self): 1768 with self.assertRaises(TypeError): 1769 type() 1770 with self.assertRaises(TypeError): 1771 type('A', ()) 1772 with self.assertRaises(TypeError): 1773 type('A', (), {}, ()) 1774 with self.assertRaises(TypeError): 1775 type('A', (), dict={}) 1776 with self.assertRaises(TypeError): 1777 type('A', [], {}) 1778 with self.assertRaises(TypeError): 1779 type('A', (), UserDict.UserDict()) 1780 with self.assertRaises(TypeError): 1781 type('A', (None,), {}) 1782 with self.assertRaises(TypeError): 1783 type('A', (bool,), {}) 1784 with self.assertRaises(TypeError): 1785 type('A', (int, str), {}) 1786 class B: 1787 pass 1788 with self.assertRaises(TypeError): 1789 type('A', (B,), {}) 1790 1791 def test_bad_slots(self): 1792 with self.assertRaises(TypeError): 1793 type('A', (long,), {'__slots__': 'x'}) 1794 with self.assertRaises(TypeError): 1795 type('A', (), {'__slots__': ''}) 1796 with self.assertRaises(TypeError): 1797 type('A', (), {'__slots__': '42'}) 1798 with self.assertRaises(TypeError): 1799 type('A', (), {'__slots__': 'x\x00y'}) 1800 with self.assertRaises(TypeError): 1801 type('A', (), {'__slots__': ('__dict__', '__dict__')}) 1802 with self.assertRaises(TypeError): 1803 type('A', (), {'__slots__': ('__weakref__', '__weakref__')}) 1804 1805 class B(object): 1806 pass 1807 with self.assertRaises(TypeError): 1808 type('A', (B,), {'__slots__': '__dict__'}) 1809 with self.assertRaises(TypeError): 1810 type('A', (B,), {'__slots__': '__weakref__'}) 1811 1812 1813def _run_unittest(*args): 1814 with check_py3k_warnings( 1815 (".+ not supported in 3.x", DeprecationWarning), 1816 (".+ is renamed to imp.reload", DeprecationWarning), 1817 ("classic int division", DeprecationWarning)): 1818 run_unittest(*args) 1819 1820def test_main(verbose=None): 1821 global numruns 1822 if not numruns: 1823 with check_py3k_warnings( 1824 (".+ not supported in 3.x", DeprecationWarning)): 1825 run_unittest(TestExecFile) 1826 numruns += 1 1827 test_classes = (BuiltinTest, TestSorted, TestType) 1828 1829 _run_unittest(*test_classes) 1830 1831 # verify reference counting 1832 if verbose and hasattr(sys, "gettotalrefcount"): 1833 import gc 1834 counts = [None] * 5 1835 for i in xrange(len(counts)): 1836 _run_unittest(*test_classes) 1837 gc.collect() 1838 counts[i] = sys.gettotalrefcount() 1839 print counts 1840 1841 1842if __name__ == "__main__": 1843 test_main(verbose=True) 1844