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