1import builtins 2import copyreg 3import gc 4import itertools 5import math 6import pickle 7import sys 8import types 9import unittest 10import warnings 11import weakref 12 13from copy import deepcopy 14from test import support 15 16 17class OperatorsTest(unittest.TestCase): 18 19 def __init__(self, *args, **kwargs): 20 unittest.TestCase.__init__(self, *args, **kwargs) 21 self.binops = { 22 'add': '+', 23 'sub': '-', 24 'mul': '*', 25 'matmul': '@', 26 'truediv': '/', 27 'floordiv': '//', 28 'divmod': 'divmod', 29 'pow': '**', 30 'lshift': '<<', 31 'rshift': '>>', 32 'and': '&', 33 'xor': '^', 34 'or': '|', 35 'cmp': 'cmp', 36 'lt': '<', 37 'le': '<=', 38 'eq': '==', 39 'ne': '!=', 40 'gt': '>', 41 'ge': '>=', 42 } 43 44 for name, expr in list(self.binops.items()): 45 if expr.islower(): 46 expr = expr + "(a, b)" 47 else: 48 expr = 'a %s b' % expr 49 self.binops[name] = expr 50 51 self.unops = { 52 'pos': '+', 53 'neg': '-', 54 'abs': 'abs', 55 'invert': '~', 56 'int': 'int', 57 'float': 'float', 58 } 59 60 for name, expr in list(self.unops.items()): 61 if expr.islower(): 62 expr = expr + "(a)" 63 else: 64 expr = '%s a' % expr 65 self.unops[name] = expr 66 67 def unop_test(self, a, res, expr="len(a)", meth="__len__"): 68 d = {'a': a} 69 self.assertEqual(eval(expr, d), res) 70 t = type(a) 71 m = getattr(t, meth) 72 73 # Find method in parent class 74 while meth not in t.__dict__: 75 t = t.__bases__[0] 76 # in some implementations (e.g. PyPy), 'm' can be a regular unbound 77 # method object; the getattr() below obtains its underlying function. 78 self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth]) 79 self.assertEqual(m(a), res) 80 bm = getattr(a, meth) 81 self.assertEqual(bm(), res) 82 83 def binop_test(self, a, b, res, expr="a+b", meth="__add__"): 84 d = {'a': a, 'b': b} 85 86 self.assertEqual(eval(expr, d), res) 87 t = type(a) 88 m = getattr(t, meth) 89 while meth not in t.__dict__: 90 t = t.__bases__[0] 91 # in some implementations (e.g. PyPy), 'm' can be a regular unbound 92 # method object; the getattr() below obtains its underlying function. 93 self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth]) 94 self.assertEqual(m(a, b), res) 95 bm = getattr(a, meth) 96 self.assertEqual(bm(b), res) 97 98 def sliceop_test(self, a, b, c, res, expr="a[b:c]", meth="__getitem__"): 99 d = {'a': a, 'b': b, 'c': c} 100 self.assertEqual(eval(expr, d), res) 101 t = type(a) 102 m = getattr(t, meth) 103 while meth not in t.__dict__: 104 t = t.__bases__[0] 105 # in some implementations (e.g. PyPy), 'm' can be a regular unbound 106 # method object; the getattr() below obtains its underlying function. 107 self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth]) 108 self.assertEqual(m(a, slice(b, c)), res) 109 bm = getattr(a, meth) 110 self.assertEqual(bm(slice(b, c)), res) 111 112 def setop_test(self, a, b, res, stmt="a+=b", meth="__iadd__"): 113 d = {'a': deepcopy(a), 'b': b} 114 exec(stmt, d) 115 self.assertEqual(d['a'], res) 116 t = type(a) 117 m = getattr(t, meth) 118 while meth not in t.__dict__: 119 t = t.__bases__[0] 120 # in some implementations (e.g. PyPy), 'm' can be a regular unbound 121 # method object; the getattr() below obtains its underlying function. 122 self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth]) 123 d['a'] = deepcopy(a) 124 m(d['a'], b) 125 self.assertEqual(d['a'], res) 126 d['a'] = deepcopy(a) 127 bm = getattr(d['a'], meth) 128 bm(b) 129 self.assertEqual(d['a'], res) 130 131 def set2op_test(self, a, b, c, res, stmt="a[b]=c", meth="__setitem__"): 132 d = {'a': deepcopy(a), 'b': b, 'c': c} 133 exec(stmt, d) 134 self.assertEqual(d['a'], res) 135 t = type(a) 136 m = getattr(t, meth) 137 while meth not in t.__dict__: 138 t = t.__bases__[0] 139 # in some implementations (e.g. PyPy), 'm' can be a regular unbound 140 # method object; the getattr() below obtains its underlying function. 141 self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth]) 142 d['a'] = deepcopy(a) 143 m(d['a'], b, c) 144 self.assertEqual(d['a'], res) 145 d['a'] = deepcopy(a) 146 bm = getattr(d['a'], meth) 147 bm(b, c) 148 self.assertEqual(d['a'], res) 149 150 def setsliceop_test(self, a, b, c, d, res, stmt="a[b:c]=d", meth="__setitem__"): 151 dictionary = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d} 152 exec(stmt, dictionary) 153 self.assertEqual(dictionary['a'], res) 154 t = type(a) 155 while meth not in t.__dict__: 156 t = t.__bases__[0] 157 m = getattr(t, meth) 158 # in some implementations (e.g. PyPy), 'm' can be a regular unbound 159 # method object; the getattr() below obtains its underlying function. 160 self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth]) 161 dictionary['a'] = deepcopy(a) 162 m(dictionary['a'], slice(b, c), d) 163 self.assertEqual(dictionary['a'], res) 164 dictionary['a'] = deepcopy(a) 165 bm = getattr(dictionary['a'], meth) 166 bm(slice(b, c), d) 167 self.assertEqual(dictionary['a'], res) 168 169 def test_lists(self): 170 # Testing list operations... 171 # Asserts are within individual test methods 172 self.binop_test([1], [2], [1,2], "a+b", "__add__") 173 self.binop_test([1,2,3], 2, 1, "b in a", "__contains__") 174 self.binop_test([1,2,3], 4, 0, "b in a", "__contains__") 175 self.binop_test([1,2,3], 1, 2, "a[b]", "__getitem__") 176 self.sliceop_test([1,2,3], 0, 2, [1,2], "a[b:c]", "__getitem__") 177 self.setop_test([1], [2], [1,2], "a+=b", "__iadd__") 178 self.setop_test([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__") 179 self.unop_test([1,2,3], 3, "len(a)", "__len__") 180 self.binop_test([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__") 181 self.binop_test([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__") 182 self.set2op_test([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__") 183 self.setsliceop_test([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", 184 "__setitem__") 185 186 def test_dicts(self): 187 # Testing dict operations... 188 self.binop_test({1:2,3:4}, 1, 1, "b in a", "__contains__") 189 self.binop_test({1:2,3:4}, 2, 0, "b in a", "__contains__") 190 self.binop_test({1:2,3:4}, 1, 2, "a[b]", "__getitem__") 191 192 d = {1:2, 3:4} 193 l1 = [] 194 for i in list(d.keys()): 195 l1.append(i) 196 l = [] 197 for i in iter(d): 198 l.append(i) 199 self.assertEqual(l, l1) 200 l = [] 201 for i in d.__iter__(): 202 l.append(i) 203 self.assertEqual(l, l1) 204 l = [] 205 for i in dict.__iter__(d): 206 l.append(i) 207 self.assertEqual(l, l1) 208 d = {1:2, 3:4} 209 self.unop_test(d, 2, "len(a)", "__len__") 210 self.assertEqual(eval(repr(d), {}), d) 211 self.assertEqual(eval(d.__repr__(), {}), d) 212 self.set2op_test({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c", 213 "__setitem__") 214 215 # Tests for unary and binary operators 216 def number_operators(self, a, b, skip=[]): 217 dict = {'a': a, 'b': b} 218 219 for name, expr in self.binops.items(): 220 if name not in skip: 221 name = "__%s__" % name 222 if hasattr(a, name): 223 res = eval(expr, dict) 224 self.binop_test(a, b, res, expr, name) 225 226 for name, expr in list(self.unops.items()): 227 if name not in skip: 228 name = "__%s__" % name 229 if hasattr(a, name): 230 res = eval(expr, dict) 231 self.unop_test(a, res, expr, name) 232 233 def test_ints(self): 234 # Testing int operations... 235 self.number_operators(100, 3) 236 # The following crashes in Python 2.2 237 self.assertEqual((1).__bool__(), 1) 238 self.assertEqual((0).__bool__(), 0) 239 # This returns 'NotImplemented' in Python 2.2 240 class C(int): 241 def __add__(self, other): 242 return NotImplemented 243 self.assertEqual(C(5), 5) 244 try: 245 C() + "" 246 except TypeError: 247 pass 248 else: 249 self.fail("NotImplemented should have caused TypeError") 250 251 def test_floats(self): 252 # Testing float operations... 253 self.number_operators(100.0, 3.0) 254 255 def test_complexes(self): 256 # Testing complex operations... 257 self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge', 258 'int', 'float', 259 'floordiv', 'divmod', 'mod']) 260 261 class Number(complex): 262 __slots__ = ['prec'] 263 def __new__(cls, *args, **kwds): 264 result = complex.__new__(cls, *args) 265 result.prec = kwds.get('prec', 12) 266 return result 267 def __repr__(self): 268 prec = self.prec 269 if self.imag == 0.0: 270 return "%.*g" % (prec, self.real) 271 if self.real == 0.0: 272 return "%.*gj" % (prec, self.imag) 273 return "(%.*g+%.*gj)" % (prec, self.real, prec, self.imag) 274 __str__ = __repr__ 275 276 a = Number(3.14, prec=6) 277 self.assertEqual(repr(a), "3.14") 278 self.assertEqual(a.prec, 6) 279 280 a = Number(a, prec=2) 281 self.assertEqual(repr(a), "3.1") 282 self.assertEqual(a.prec, 2) 283 284 a = Number(234.5) 285 self.assertEqual(repr(a), "234.5") 286 self.assertEqual(a.prec, 12) 287 288 def test_explicit_reverse_methods(self): 289 # see issue 9930 290 self.assertEqual(complex.__radd__(3j, 4.0), complex(4.0, 3.0)) 291 self.assertEqual(float.__rsub__(3.0, 1), -2.0) 292 293 @support.impl_detail("the module 'xxsubtype' is internal") 294 def test_spam_lists(self): 295 # Testing spamlist operations... 296 import copy, xxsubtype as spam 297 298 def spamlist(l, memo=None): 299 import xxsubtype as spam 300 return spam.spamlist(l) 301 302 # This is an ugly hack: 303 copy._deepcopy_dispatch[spam.spamlist] = spamlist 304 305 self.binop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b", 306 "__add__") 307 self.binop_test(spamlist([1,2,3]), 2, 1, "b in a", "__contains__") 308 self.binop_test(spamlist([1,2,3]), 4, 0, "b in a", "__contains__") 309 self.binop_test(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__") 310 self.sliceop_test(spamlist([1,2,3]), 0, 2, spamlist([1,2]), "a[b:c]", 311 "__getitem__") 312 self.setop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+=b", 313 "__iadd__") 314 self.setop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", 315 "__imul__") 316 self.unop_test(spamlist([1,2,3]), 3, "len(a)", "__len__") 317 self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", 318 "__mul__") 319 self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", 320 "__rmul__") 321 self.set2op_test(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", 322 "__setitem__") 323 self.setsliceop_test(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]), 324 spamlist([1,5,6,4]), "a[b:c]=d", "__setitem__") 325 # Test subclassing 326 class C(spam.spamlist): 327 def foo(self): return 1 328 a = C() 329 self.assertEqual(a, []) 330 self.assertEqual(a.foo(), 1) 331 a.append(100) 332 self.assertEqual(a, [100]) 333 self.assertEqual(a.getstate(), 0) 334 a.setstate(42) 335 self.assertEqual(a.getstate(), 42) 336 337 @support.impl_detail("the module 'xxsubtype' is internal") 338 def test_spam_dicts(self): 339 # Testing spamdict operations... 340 import copy, xxsubtype as spam 341 def spamdict(d, memo=None): 342 import xxsubtype as spam 343 sd = spam.spamdict() 344 for k, v in list(d.items()): 345 sd[k] = v 346 return sd 347 # This is an ugly hack: 348 copy._deepcopy_dispatch[spam.spamdict] = spamdict 349 350 self.binop_test(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__") 351 self.binop_test(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__") 352 self.binop_test(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__") 353 d = spamdict({1:2,3:4}) 354 l1 = [] 355 for i in list(d.keys()): 356 l1.append(i) 357 l = [] 358 for i in iter(d): 359 l.append(i) 360 self.assertEqual(l, l1) 361 l = [] 362 for i in d.__iter__(): 363 l.append(i) 364 self.assertEqual(l, l1) 365 l = [] 366 for i in type(spamdict({})).__iter__(d): 367 l.append(i) 368 self.assertEqual(l, l1) 369 straightd = {1:2, 3:4} 370 spamd = spamdict(straightd) 371 self.unop_test(spamd, 2, "len(a)", "__len__") 372 self.unop_test(spamd, repr(straightd), "repr(a)", "__repr__") 373 self.set2op_test(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}), 374 "a[b]=c", "__setitem__") 375 # Test subclassing 376 class C(spam.spamdict): 377 def foo(self): return 1 378 a = C() 379 self.assertEqual(list(a.items()), []) 380 self.assertEqual(a.foo(), 1) 381 a['foo'] = 'bar' 382 self.assertEqual(list(a.items()), [('foo', 'bar')]) 383 self.assertEqual(a.getstate(), 0) 384 a.setstate(100) 385 self.assertEqual(a.getstate(), 100) 386 387class ClassPropertiesAndMethods(unittest.TestCase): 388 389 def assertHasAttr(self, obj, name): 390 self.assertTrue(hasattr(obj, name), 391 '%r has no attribute %r' % (obj, name)) 392 393 def assertNotHasAttr(self, obj, name): 394 self.assertFalse(hasattr(obj, name), 395 '%r has unexpected attribute %r' % (obj, name)) 396 397 def test_python_dicts(self): 398 # Testing Python subclass of dict... 399 self.assertTrue(issubclass(dict, dict)) 400 self.assertIsInstance({}, dict) 401 d = dict() 402 self.assertEqual(d, {}) 403 self.assertIs(d.__class__, dict) 404 self.assertIsInstance(d, dict) 405 class C(dict): 406 state = -1 407 def __init__(self_local, *a, **kw): 408 if a: 409 self.assertEqual(len(a), 1) 410 self_local.state = a[0] 411 if kw: 412 for k, v in list(kw.items()): 413 self_local[v] = k 414 def __getitem__(self, key): 415 return self.get(key, 0) 416 def __setitem__(self_local, key, value): 417 self.assertIsInstance(key, type(0)) 418 dict.__setitem__(self_local, key, value) 419 def setstate(self, state): 420 self.state = state 421 def getstate(self): 422 return self.state 423 self.assertTrue(issubclass(C, dict)) 424 a1 = C(12) 425 self.assertEqual(a1.state, 12) 426 a2 = C(foo=1, bar=2) 427 self.assertEqual(a2[1] == 'foo' and a2[2], 'bar') 428 a = C() 429 self.assertEqual(a.state, -1) 430 self.assertEqual(a.getstate(), -1) 431 a.setstate(0) 432 self.assertEqual(a.state, 0) 433 self.assertEqual(a.getstate(), 0) 434 a.setstate(10) 435 self.assertEqual(a.state, 10) 436 self.assertEqual(a.getstate(), 10) 437 self.assertEqual(a[42], 0) 438 a[42] = 24 439 self.assertEqual(a[42], 24) 440 N = 50 441 for i in range(N): 442 a[i] = C() 443 for j in range(N): 444 a[i][j] = i*j 445 for i in range(N): 446 for j in range(N): 447 self.assertEqual(a[i][j], i*j) 448 449 def test_python_lists(self): 450 # Testing Python subclass of list... 451 class C(list): 452 def __getitem__(self, i): 453 if isinstance(i, slice): 454 return i.start, i.stop 455 return list.__getitem__(self, i) + 100 456 a = C() 457 a.extend([0,1,2]) 458 self.assertEqual(a[0], 100) 459 self.assertEqual(a[1], 101) 460 self.assertEqual(a[2], 102) 461 self.assertEqual(a[100:200], (100,200)) 462 463 def test_metaclass(self): 464 # Testing metaclasses... 465 class C(metaclass=type): 466 def __init__(self): 467 self.__state = 0 468 def getstate(self): 469 return self.__state 470 def setstate(self, state): 471 self.__state = state 472 a = C() 473 self.assertEqual(a.getstate(), 0) 474 a.setstate(10) 475 self.assertEqual(a.getstate(), 10) 476 class _metaclass(type): 477 def myself(cls): return cls 478 class D(metaclass=_metaclass): 479 pass 480 self.assertEqual(D.myself(), D) 481 d = D() 482 self.assertEqual(d.__class__, D) 483 class M1(type): 484 def __new__(cls, name, bases, dict): 485 dict['__spam__'] = 1 486 return type.__new__(cls, name, bases, dict) 487 class C(metaclass=M1): 488 pass 489 self.assertEqual(C.__spam__, 1) 490 c = C() 491 self.assertEqual(c.__spam__, 1) 492 493 class _instance(object): 494 pass 495 class M2(object): 496 @staticmethod 497 def __new__(cls, name, bases, dict): 498 self = object.__new__(cls) 499 self.name = name 500 self.bases = bases 501 self.dict = dict 502 return self 503 def __call__(self): 504 it = _instance() 505 # Early binding of methods 506 for key in self.dict: 507 if key.startswith("__"): 508 continue 509 setattr(it, key, self.dict[key].__get__(it, self)) 510 return it 511 class C(metaclass=M2): 512 def spam(self): 513 return 42 514 self.assertEqual(C.name, 'C') 515 self.assertEqual(C.bases, ()) 516 self.assertIn('spam', C.dict) 517 c = C() 518 self.assertEqual(c.spam(), 42) 519 520 # More metaclass examples 521 522 class autosuper(type): 523 # Automatically add __super to the class 524 # This trick only works for dynamic classes 525 def __new__(metaclass, name, bases, dict): 526 cls = super(autosuper, metaclass).__new__(metaclass, 527 name, bases, dict) 528 # Name mangling for __super removes leading underscores 529 while name[:1] == "_": 530 name = name[1:] 531 if name: 532 name = "_%s__super" % name 533 else: 534 name = "__super" 535 setattr(cls, name, super(cls)) 536 return cls 537 class A(metaclass=autosuper): 538 def meth(self): 539 return "A" 540 class B(A): 541 def meth(self): 542 return "B" + self.__super.meth() 543 class C(A): 544 def meth(self): 545 return "C" + self.__super.meth() 546 class D(C, B): 547 def meth(self): 548 return "D" + self.__super.meth() 549 self.assertEqual(D().meth(), "DCBA") 550 class E(B, C): 551 def meth(self): 552 return "E" + self.__super.meth() 553 self.assertEqual(E().meth(), "EBCA") 554 555 class autoproperty(type): 556 # Automatically create property attributes when methods 557 # named _get_x and/or _set_x are found 558 def __new__(metaclass, name, bases, dict): 559 hits = {} 560 for key, val in dict.items(): 561 if key.startswith("_get_"): 562 key = key[5:] 563 get, set = hits.get(key, (None, None)) 564 get = val 565 hits[key] = get, set 566 elif key.startswith("_set_"): 567 key = key[5:] 568 get, set = hits.get(key, (None, None)) 569 set = val 570 hits[key] = get, set 571 for key, (get, set) in hits.items(): 572 dict[key] = property(get, set) 573 return super(autoproperty, metaclass).__new__(metaclass, 574 name, bases, dict) 575 class A(metaclass=autoproperty): 576 def _get_x(self): 577 return -self.__x 578 def _set_x(self, x): 579 self.__x = -x 580 a = A() 581 self.assertNotHasAttr(a, "x") 582 a.x = 12 583 self.assertEqual(a.x, 12) 584 self.assertEqual(a._A__x, -12) 585 586 class multimetaclass(autoproperty, autosuper): 587 # Merge of multiple cooperating metaclasses 588 pass 589 class A(metaclass=multimetaclass): 590 def _get_x(self): 591 return "A" 592 class B(A): 593 def _get_x(self): 594 return "B" + self.__super._get_x() 595 class C(A): 596 def _get_x(self): 597 return "C" + self.__super._get_x() 598 class D(C, B): 599 def _get_x(self): 600 return "D" + self.__super._get_x() 601 self.assertEqual(D().x, "DCBA") 602 603 # Make sure type(x) doesn't call x.__class__.__init__ 604 class T(type): 605 counter = 0 606 def __init__(self, *args): 607 T.counter += 1 608 class C(metaclass=T): 609 pass 610 self.assertEqual(T.counter, 1) 611 a = C() 612 self.assertEqual(type(a), C) 613 self.assertEqual(T.counter, 1) 614 615 class C(object): pass 616 c = C() 617 try: c() 618 except TypeError: pass 619 else: self.fail("calling object w/o call method should raise " 620 "TypeError") 621 622 # Testing code to find most derived baseclass 623 class A(type): 624 def __new__(*args, **kwargs): 625 return type.__new__(*args, **kwargs) 626 627 class B(object): 628 pass 629 630 class C(object, metaclass=A): 631 pass 632 633 # The most derived metaclass of D is A rather than type. 634 class D(B, C): 635 pass 636 self.assertIs(A, type(D)) 637 638 # issue1294232: correct metaclass calculation 639 new_calls = [] # to check the order of __new__ calls 640 class AMeta(type): 641 @staticmethod 642 def __new__(mcls, name, bases, ns): 643 new_calls.append('AMeta') 644 return super().__new__(mcls, name, bases, ns) 645 @classmethod 646 def __prepare__(mcls, name, bases): 647 return {} 648 649 class BMeta(AMeta): 650 @staticmethod 651 def __new__(mcls, name, bases, ns): 652 new_calls.append('BMeta') 653 return super().__new__(mcls, name, bases, ns) 654 @classmethod 655 def __prepare__(mcls, name, bases): 656 ns = super().__prepare__(name, bases) 657 ns['BMeta_was_here'] = True 658 return ns 659 660 class A(metaclass=AMeta): 661 pass 662 self.assertEqual(['AMeta'], new_calls) 663 new_calls.clear() 664 665 class B(metaclass=BMeta): 666 pass 667 # BMeta.__new__ calls AMeta.__new__ with super: 668 self.assertEqual(['BMeta', 'AMeta'], new_calls) 669 new_calls.clear() 670 671 class C(A, B): 672 pass 673 # The most derived metaclass is BMeta: 674 self.assertEqual(['BMeta', 'AMeta'], new_calls) 675 new_calls.clear() 676 # BMeta.__prepare__ should've been called: 677 self.assertIn('BMeta_was_here', C.__dict__) 678 679 # The order of the bases shouldn't matter: 680 class C2(B, A): 681 pass 682 self.assertEqual(['BMeta', 'AMeta'], new_calls) 683 new_calls.clear() 684 self.assertIn('BMeta_was_here', C2.__dict__) 685 686 # Check correct metaclass calculation when a metaclass is declared: 687 class D(C, metaclass=type): 688 pass 689 self.assertEqual(['BMeta', 'AMeta'], new_calls) 690 new_calls.clear() 691 self.assertIn('BMeta_was_here', D.__dict__) 692 693 class E(C, metaclass=AMeta): 694 pass 695 self.assertEqual(['BMeta', 'AMeta'], new_calls) 696 new_calls.clear() 697 self.assertIn('BMeta_was_here', E.__dict__) 698 699 # Special case: the given metaclass isn't a class, 700 # so there is no metaclass calculation. 701 marker = object() 702 def func(*args, **kwargs): 703 return marker 704 class X(metaclass=func): 705 pass 706 class Y(object, metaclass=func): 707 pass 708 class Z(D, metaclass=func): 709 pass 710 self.assertIs(marker, X) 711 self.assertIs(marker, Y) 712 self.assertIs(marker, Z) 713 714 # The given metaclass is a class, 715 # but not a descendant of type. 716 prepare_calls = [] # to track __prepare__ calls 717 class ANotMeta: 718 def __new__(mcls, *args, **kwargs): 719 new_calls.append('ANotMeta') 720 return super().__new__(mcls) 721 @classmethod 722 def __prepare__(mcls, name, bases): 723 prepare_calls.append('ANotMeta') 724 return {} 725 class BNotMeta(ANotMeta): 726 def __new__(mcls, *args, **kwargs): 727 new_calls.append('BNotMeta') 728 return super().__new__(mcls) 729 @classmethod 730 def __prepare__(mcls, name, bases): 731 prepare_calls.append('BNotMeta') 732 return super().__prepare__(name, bases) 733 734 class A(metaclass=ANotMeta): 735 pass 736 self.assertIs(ANotMeta, type(A)) 737 self.assertEqual(['ANotMeta'], prepare_calls) 738 prepare_calls.clear() 739 self.assertEqual(['ANotMeta'], new_calls) 740 new_calls.clear() 741 742 class B(metaclass=BNotMeta): 743 pass 744 self.assertIs(BNotMeta, type(B)) 745 self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls) 746 prepare_calls.clear() 747 self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls) 748 new_calls.clear() 749 750 class C(A, B): 751 pass 752 self.assertIs(BNotMeta, type(C)) 753 self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls) 754 new_calls.clear() 755 self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls) 756 prepare_calls.clear() 757 758 class C2(B, A): 759 pass 760 self.assertIs(BNotMeta, type(C2)) 761 self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls) 762 new_calls.clear() 763 self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls) 764 prepare_calls.clear() 765 766 # This is a TypeError, because of a metaclass conflict: 767 # BNotMeta is neither a subclass, nor a superclass of type 768 with self.assertRaises(TypeError): 769 class D(C, metaclass=type): 770 pass 771 772 class E(C, metaclass=ANotMeta): 773 pass 774 self.assertIs(BNotMeta, type(E)) 775 self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls) 776 new_calls.clear() 777 self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls) 778 prepare_calls.clear() 779 780 class F(object(), C): 781 pass 782 self.assertIs(BNotMeta, type(F)) 783 self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls) 784 new_calls.clear() 785 self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls) 786 prepare_calls.clear() 787 788 class F2(C, object()): 789 pass 790 self.assertIs(BNotMeta, type(F2)) 791 self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls) 792 new_calls.clear() 793 self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls) 794 prepare_calls.clear() 795 796 # TypeError: BNotMeta is neither a 797 # subclass, nor a superclass of int 798 with self.assertRaises(TypeError): 799 class X(C, int()): 800 pass 801 with self.assertRaises(TypeError): 802 class X(int(), C): 803 pass 804 805 def test_module_subclasses(self): 806 # Testing Python subclass of module... 807 log = [] 808 MT = type(sys) 809 class MM(MT): 810 def __init__(self, name): 811 MT.__init__(self, name) 812 def __getattribute__(self, name): 813 log.append(("getattr", name)) 814 return MT.__getattribute__(self, name) 815 def __setattr__(self, name, value): 816 log.append(("setattr", name, value)) 817 MT.__setattr__(self, name, value) 818 def __delattr__(self, name): 819 log.append(("delattr", name)) 820 MT.__delattr__(self, name) 821 a = MM("a") 822 a.foo = 12 823 x = a.foo 824 del a.foo 825 self.assertEqual(log, [("setattr", "foo", 12), 826 ("getattr", "foo"), 827 ("delattr", "foo")]) 828 829 # http://python.org/sf/1174712 830 try: 831 class Module(types.ModuleType, str): 832 pass 833 except TypeError: 834 pass 835 else: 836 self.fail("inheriting from ModuleType and str at the same time " 837 "should fail") 838 839 def test_multiple_inheritance(self): 840 # Testing multiple inheritance... 841 class C(object): 842 def __init__(self): 843 self.__state = 0 844 def getstate(self): 845 return self.__state 846 def setstate(self, state): 847 self.__state = state 848 a = C() 849 self.assertEqual(a.getstate(), 0) 850 a.setstate(10) 851 self.assertEqual(a.getstate(), 10) 852 class D(dict, C): 853 def __init__(self): 854 type({}).__init__(self) 855 C.__init__(self) 856 d = D() 857 self.assertEqual(list(d.keys()), []) 858 d["hello"] = "world" 859 self.assertEqual(list(d.items()), [("hello", "world")]) 860 self.assertEqual(d["hello"], "world") 861 self.assertEqual(d.getstate(), 0) 862 d.setstate(10) 863 self.assertEqual(d.getstate(), 10) 864 self.assertEqual(D.__mro__, (D, dict, C, object)) 865 866 # SF bug #442833 867 class Node(object): 868 def __int__(self): 869 return int(self.foo()) 870 def foo(self): 871 return "23" 872 class Frag(Node, list): 873 def foo(self): 874 return "42" 875 self.assertEqual(Node().__int__(), 23) 876 self.assertEqual(int(Node()), 23) 877 self.assertEqual(Frag().__int__(), 42) 878 self.assertEqual(int(Frag()), 42) 879 880 def test_diamond_inheritance(self): 881 # Testing multiple inheritance special cases... 882 class A(object): 883 def spam(self): return "A" 884 self.assertEqual(A().spam(), "A") 885 class B(A): 886 def boo(self): return "B" 887 def spam(self): return "B" 888 self.assertEqual(B().spam(), "B") 889 self.assertEqual(B().boo(), "B") 890 class C(A): 891 def boo(self): return "C" 892 self.assertEqual(C().spam(), "A") 893 self.assertEqual(C().boo(), "C") 894 class D(B, C): pass 895 self.assertEqual(D().spam(), "B") 896 self.assertEqual(D().boo(), "B") 897 self.assertEqual(D.__mro__, (D, B, C, A, object)) 898 class E(C, B): pass 899 self.assertEqual(E().spam(), "B") 900 self.assertEqual(E().boo(), "C") 901 self.assertEqual(E.__mro__, (E, C, B, A, object)) 902 # MRO order disagreement 903 try: 904 class F(D, E): pass 905 except TypeError: 906 pass 907 else: 908 self.fail("expected MRO order disagreement (F)") 909 try: 910 class G(E, D): pass 911 except TypeError: 912 pass 913 else: 914 self.fail("expected MRO order disagreement (G)") 915 916 # see thread python-dev/2002-October/029035.html 917 def test_ex5_from_c3_switch(self): 918 # Testing ex5 from C3 switch discussion... 919 class A(object): pass 920 class B(object): pass 921 class C(object): pass 922 class X(A): pass 923 class Y(A): pass 924 class Z(X,B,Y,C): pass 925 self.assertEqual(Z.__mro__, (Z, X, B, Y, A, C, object)) 926 927 # see "A Monotonic Superclass Linearization for Dylan", 928 # by Kim Barrett et al. (OOPSLA 1996) 929 def test_monotonicity(self): 930 # Testing MRO monotonicity... 931 class Boat(object): pass 932 class DayBoat(Boat): pass 933 class WheelBoat(Boat): pass 934 class EngineLess(DayBoat): pass 935 class SmallMultihull(DayBoat): pass 936 class PedalWheelBoat(EngineLess,WheelBoat): pass 937 class SmallCatamaran(SmallMultihull): pass 938 class Pedalo(PedalWheelBoat,SmallCatamaran): pass 939 940 self.assertEqual(PedalWheelBoat.__mro__, 941 (PedalWheelBoat, EngineLess, DayBoat, WheelBoat, Boat, object)) 942 self.assertEqual(SmallCatamaran.__mro__, 943 (SmallCatamaran, SmallMultihull, DayBoat, Boat, object)) 944 self.assertEqual(Pedalo.__mro__, 945 (Pedalo, PedalWheelBoat, EngineLess, SmallCatamaran, 946 SmallMultihull, DayBoat, WheelBoat, Boat, object)) 947 948 # see "A Monotonic Superclass Linearization for Dylan", 949 # by Kim Barrett et al. (OOPSLA 1996) 950 def test_consistency_with_epg(self): 951 # Testing consistency with EPG... 952 class Pane(object): pass 953 class ScrollingMixin(object): pass 954 class EditingMixin(object): pass 955 class ScrollablePane(Pane,ScrollingMixin): pass 956 class EditablePane(Pane,EditingMixin): pass 957 class EditableScrollablePane(ScrollablePane,EditablePane): pass 958 959 self.assertEqual(EditableScrollablePane.__mro__, 960 (EditableScrollablePane, ScrollablePane, EditablePane, Pane, 961 ScrollingMixin, EditingMixin, object)) 962 963 def test_mro_disagreement(self): 964 # Testing error messages for MRO disagreement... 965 mro_err_msg = """Cannot create a consistent method resolution 966order (MRO) for bases """ 967 968 def raises(exc, expected, callable, *args): 969 try: 970 callable(*args) 971 except exc as msg: 972 # the exact msg is generally considered an impl detail 973 if support.check_impl_detail(): 974 if not str(msg).startswith(expected): 975 self.fail("Message %r, expected %r" % 976 (str(msg), expected)) 977 else: 978 self.fail("Expected %s" % exc) 979 980 class A(object): pass 981 class B(A): pass 982 class C(object): pass 983 984 # Test some very simple errors 985 raises(TypeError, "duplicate base class A", 986 type, "X", (A, A), {}) 987 raises(TypeError, mro_err_msg, 988 type, "X", (A, B), {}) 989 raises(TypeError, mro_err_msg, 990 type, "X", (A, C, B), {}) 991 # Test a slightly more complex error 992 class GridLayout(object): pass 993 class HorizontalGrid(GridLayout): pass 994 class VerticalGrid(GridLayout): pass 995 class HVGrid(HorizontalGrid, VerticalGrid): pass 996 class VHGrid(VerticalGrid, HorizontalGrid): pass 997 raises(TypeError, mro_err_msg, 998 type, "ConfusedGrid", (HVGrid, VHGrid), {}) 999 1000 def test_object_class(self): 1001 # Testing object class... 1002 a = object() 1003 self.assertEqual(a.__class__, object) 1004 self.assertEqual(type(a), object) 1005 b = object() 1006 self.assertNotEqual(a, b) 1007 self.assertNotHasAttr(a, "foo") 1008 try: 1009 a.foo = 12 1010 except (AttributeError, TypeError): 1011 pass 1012 else: 1013 self.fail("object() should not allow setting a foo attribute") 1014 self.assertNotHasAttr(object(), "__dict__") 1015 1016 class Cdict(object): 1017 pass 1018 x = Cdict() 1019 self.assertEqual(x.__dict__, {}) 1020 x.foo = 1 1021 self.assertEqual(x.foo, 1) 1022 self.assertEqual(x.__dict__, {'foo': 1}) 1023 1024 def test_object_class_assignment_between_heaptypes_and_nonheaptypes(self): 1025 class SubType(types.ModuleType): 1026 a = 1 1027 1028 m = types.ModuleType("m") 1029 self.assertTrue(m.__class__ is types.ModuleType) 1030 self.assertFalse(hasattr(m, "a")) 1031 1032 m.__class__ = SubType 1033 self.assertTrue(m.__class__ is SubType) 1034 self.assertTrue(hasattr(m, "a")) 1035 1036 m.__class__ = types.ModuleType 1037 self.assertTrue(m.__class__ is types.ModuleType) 1038 self.assertFalse(hasattr(m, "a")) 1039 1040 # Make sure that builtin immutable objects don't support __class__ 1041 # assignment, because the object instances may be interned. 1042 # We set __slots__ = () to ensure that the subclasses are 1043 # memory-layout compatible, and thus otherwise reasonable candidates 1044 # for __class__ assignment. 1045 1046 # The following types have immutable instances, but are not 1047 # subclassable and thus don't need to be checked: 1048 # NoneType, bool 1049 1050 class MyInt(int): 1051 __slots__ = () 1052 with self.assertRaises(TypeError): 1053 (1).__class__ = MyInt 1054 1055 class MyFloat(float): 1056 __slots__ = () 1057 with self.assertRaises(TypeError): 1058 (1.0).__class__ = MyFloat 1059 1060 class MyComplex(complex): 1061 __slots__ = () 1062 with self.assertRaises(TypeError): 1063 (1 + 2j).__class__ = MyComplex 1064 1065 class MyStr(str): 1066 __slots__ = () 1067 with self.assertRaises(TypeError): 1068 "a".__class__ = MyStr 1069 1070 class MyBytes(bytes): 1071 __slots__ = () 1072 with self.assertRaises(TypeError): 1073 b"a".__class__ = MyBytes 1074 1075 class MyTuple(tuple): 1076 __slots__ = () 1077 with self.assertRaises(TypeError): 1078 ().__class__ = MyTuple 1079 1080 class MyFrozenSet(frozenset): 1081 __slots__ = () 1082 with self.assertRaises(TypeError): 1083 frozenset().__class__ = MyFrozenSet 1084 1085 def test_slots(self): 1086 # Testing __slots__... 1087 class C0(object): 1088 __slots__ = [] 1089 x = C0() 1090 self.assertNotHasAttr(x, "__dict__") 1091 self.assertNotHasAttr(x, "foo") 1092 1093 class C1(object): 1094 __slots__ = ['a'] 1095 x = C1() 1096 self.assertNotHasAttr(x, "__dict__") 1097 self.assertNotHasAttr(x, "a") 1098 x.a = 1 1099 self.assertEqual(x.a, 1) 1100 x.a = None 1101 self.assertEqual(x.a, None) 1102 del x.a 1103 self.assertNotHasAttr(x, "a") 1104 1105 class C3(object): 1106 __slots__ = ['a', 'b', 'c'] 1107 x = C3() 1108 self.assertNotHasAttr(x, "__dict__") 1109 self.assertNotHasAttr(x, 'a') 1110 self.assertNotHasAttr(x, 'b') 1111 self.assertNotHasAttr(x, 'c') 1112 x.a = 1 1113 x.b = 2 1114 x.c = 3 1115 self.assertEqual(x.a, 1) 1116 self.assertEqual(x.b, 2) 1117 self.assertEqual(x.c, 3) 1118 1119 class C4(object): 1120 """Validate name mangling""" 1121 __slots__ = ['__a'] 1122 def __init__(self, value): 1123 self.__a = value 1124 def get(self): 1125 return self.__a 1126 x = C4(5) 1127 self.assertNotHasAttr(x, '__dict__') 1128 self.assertNotHasAttr(x, '__a') 1129 self.assertEqual(x.get(), 5) 1130 try: 1131 x.__a = 6 1132 except AttributeError: 1133 pass 1134 else: 1135 self.fail("Double underscored names not mangled") 1136 1137 # Make sure slot names are proper identifiers 1138 try: 1139 class C(object): 1140 __slots__ = [None] 1141 except TypeError: 1142 pass 1143 else: 1144 self.fail("[None] slots not caught") 1145 try: 1146 class C(object): 1147 __slots__ = ["foo bar"] 1148 except TypeError: 1149 pass 1150 else: 1151 self.fail("['foo bar'] slots not caught") 1152 try: 1153 class C(object): 1154 __slots__ = ["foo\0bar"] 1155 except TypeError: 1156 pass 1157 else: 1158 self.fail("['foo\\0bar'] slots not caught") 1159 try: 1160 class C(object): 1161 __slots__ = ["1"] 1162 except TypeError: 1163 pass 1164 else: 1165 self.fail("['1'] slots not caught") 1166 try: 1167 class C(object): 1168 __slots__ = [""] 1169 except TypeError: 1170 pass 1171 else: 1172 self.fail("[''] slots not caught") 1173 class C(object): 1174 __slots__ = ["a", "a_b", "_a", "A0123456789Z"] 1175 # XXX(nnorwitz): was there supposed to be something tested 1176 # from the class above? 1177 1178 # Test a single string is not expanded as a sequence. 1179 class C(object): 1180 __slots__ = "abc" 1181 c = C() 1182 c.abc = 5 1183 self.assertEqual(c.abc, 5) 1184 1185 # Test unicode slot names 1186 # Test a single unicode string is not expanded as a sequence. 1187 class C(object): 1188 __slots__ = "abc" 1189 c = C() 1190 c.abc = 5 1191 self.assertEqual(c.abc, 5) 1192 1193 # _unicode_to_string used to modify slots in certain circumstances 1194 slots = ("foo", "bar") 1195 class C(object): 1196 __slots__ = slots 1197 x = C() 1198 x.foo = 5 1199 self.assertEqual(x.foo, 5) 1200 self.assertIs(type(slots[0]), str) 1201 # this used to leak references 1202 try: 1203 class C(object): 1204 __slots__ = [chr(128)] 1205 except (TypeError, UnicodeEncodeError): 1206 pass 1207 else: 1208 self.fail("[chr(128)] slots not caught") 1209 1210 # Test leaks 1211 class Counted(object): 1212 counter = 0 # counts the number of instances alive 1213 def __init__(self): 1214 Counted.counter += 1 1215 def __del__(self): 1216 Counted.counter -= 1 1217 class C(object): 1218 __slots__ = ['a', 'b', 'c'] 1219 x = C() 1220 x.a = Counted() 1221 x.b = Counted() 1222 x.c = Counted() 1223 self.assertEqual(Counted.counter, 3) 1224 del x 1225 support.gc_collect() 1226 self.assertEqual(Counted.counter, 0) 1227 class D(C): 1228 pass 1229 x = D() 1230 x.a = Counted() 1231 x.z = Counted() 1232 self.assertEqual(Counted.counter, 2) 1233 del x 1234 support.gc_collect() 1235 self.assertEqual(Counted.counter, 0) 1236 class E(D): 1237 __slots__ = ['e'] 1238 x = E() 1239 x.a = Counted() 1240 x.z = Counted() 1241 x.e = Counted() 1242 self.assertEqual(Counted.counter, 3) 1243 del x 1244 support.gc_collect() 1245 self.assertEqual(Counted.counter, 0) 1246 1247 # Test cyclical leaks [SF bug 519621] 1248 class F(object): 1249 __slots__ = ['a', 'b'] 1250 s = F() 1251 s.a = [Counted(), s] 1252 self.assertEqual(Counted.counter, 1) 1253 s = None 1254 support.gc_collect() 1255 self.assertEqual(Counted.counter, 0) 1256 1257 # Test lookup leaks [SF bug 572567] 1258 if hasattr(gc, 'get_objects'): 1259 class G(object): 1260 def __eq__(self, other): 1261 return False 1262 g = G() 1263 orig_objects = len(gc.get_objects()) 1264 for i in range(10): 1265 g==g 1266 new_objects = len(gc.get_objects()) 1267 self.assertEqual(orig_objects, new_objects) 1268 1269 class H(object): 1270 __slots__ = ['a', 'b'] 1271 def __init__(self): 1272 self.a = 1 1273 self.b = 2 1274 def __del__(self_): 1275 self.assertEqual(self_.a, 1) 1276 self.assertEqual(self_.b, 2) 1277 with support.captured_output('stderr') as s: 1278 h = H() 1279 del h 1280 self.assertEqual(s.getvalue(), '') 1281 1282 class X(object): 1283 __slots__ = "a" 1284 with self.assertRaises(AttributeError): 1285 del X().a 1286 1287 def test_slots_special(self): 1288 # Testing __dict__ and __weakref__ in __slots__... 1289 class D(object): 1290 __slots__ = ["__dict__"] 1291 a = D() 1292 self.assertHasAttr(a, "__dict__") 1293 self.assertNotHasAttr(a, "__weakref__") 1294 a.foo = 42 1295 self.assertEqual(a.__dict__, {"foo": 42}) 1296 1297 class W(object): 1298 __slots__ = ["__weakref__"] 1299 a = W() 1300 self.assertHasAttr(a, "__weakref__") 1301 self.assertNotHasAttr(a, "__dict__") 1302 try: 1303 a.foo = 42 1304 except AttributeError: 1305 pass 1306 else: 1307 self.fail("shouldn't be allowed to set a.foo") 1308 1309 class C1(W, D): 1310 __slots__ = [] 1311 a = C1() 1312 self.assertHasAttr(a, "__dict__") 1313 self.assertHasAttr(a, "__weakref__") 1314 a.foo = 42 1315 self.assertEqual(a.__dict__, {"foo": 42}) 1316 1317 class C2(D, W): 1318 __slots__ = [] 1319 a = C2() 1320 self.assertHasAttr(a, "__dict__") 1321 self.assertHasAttr(a, "__weakref__") 1322 a.foo = 42 1323 self.assertEqual(a.__dict__, {"foo": 42}) 1324 1325 def test_slots_special2(self): 1326 # Testing __qualname__ and __classcell__ in __slots__ 1327 class Meta(type): 1328 def __new__(cls, name, bases, namespace, attr): 1329 self.assertIn(attr, namespace) 1330 return super().__new__(cls, name, bases, namespace) 1331 1332 class C1: 1333 def __init__(self): 1334 self.b = 42 1335 class C2(C1, metaclass=Meta, attr="__classcell__"): 1336 __slots__ = ["__classcell__"] 1337 def __init__(self): 1338 super().__init__() 1339 self.assertIsInstance(C2.__dict__["__classcell__"], 1340 types.MemberDescriptorType) 1341 c = C2() 1342 self.assertEqual(c.b, 42) 1343 self.assertNotHasAttr(c, "__classcell__") 1344 c.__classcell__ = 42 1345 self.assertEqual(c.__classcell__, 42) 1346 with self.assertRaises(TypeError): 1347 class C3: 1348 __classcell__ = 42 1349 __slots__ = ["__classcell__"] 1350 1351 class Q1(metaclass=Meta, attr="__qualname__"): 1352 __slots__ = ["__qualname__"] 1353 self.assertEqual(Q1.__qualname__, C1.__qualname__[:-2] + "Q1") 1354 self.assertIsInstance(Q1.__dict__["__qualname__"], 1355 types.MemberDescriptorType) 1356 q = Q1() 1357 self.assertNotHasAttr(q, "__qualname__") 1358 q.__qualname__ = "q" 1359 self.assertEqual(q.__qualname__, "q") 1360 with self.assertRaises(TypeError): 1361 class Q2: 1362 __qualname__ = object() 1363 __slots__ = ["__qualname__"] 1364 1365 def test_slots_descriptor(self): 1366 # Issue2115: slot descriptors did not correctly check 1367 # the type of the given object 1368 import abc 1369 class MyABC(metaclass=abc.ABCMeta): 1370 __slots__ = "a" 1371 1372 class Unrelated(object): 1373 pass 1374 MyABC.register(Unrelated) 1375 1376 u = Unrelated() 1377 self.assertIsInstance(u, MyABC) 1378 1379 # This used to crash 1380 self.assertRaises(TypeError, MyABC.a.__set__, u, 3) 1381 1382 def test_dynamics(self): 1383 # Testing class attribute propagation... 1384 class D(object): 1385 pass 1386 class E(D): 1387 pass 1388 class F(D): 1389 pass 1390 D.foo = 1 1391 self.assertEqual(D.foo, 1) 1392 # Test that dynamic attributes are inherited 1393 self.assertEqual(E.foo, 1) 1394 self.assertEqual(F.foo, 1) 1395 # Test dynamic instances 1396 class C(object): 1397 pass 1398 a = C() 1399 self.assertNotHasAttr(a, "foobar") 1400 C.foobar = 2 1401 self.assertEqual(a.foobar, 2) 1402 C.method = lambda self: 42 1403 self.assertEqual(a.method(), 42) 1404 C.__repr__ = lambda self: "C()" 1405 self.assertEqual(repr(a), "C()") 1406 C.__int__ = lambda self: 100 1407 self.assertEqual(int(a), 100) 1408 self.assertEqual(a.foobar, 2) 1409 self.assertNotHasAttr(a, "spam") 1410 def mygetattr(self, name): 1411 if name == "spam": 1412 return "spam" 1413 raise AttributeError 1414 C.__getattr__ = mygetattr 1415 self.assertEqual(a.spam, "spam") 1416 a.new = 12 1417 self.assertEqual(a.new, 12) 1418 def mysetattr(self, name, value): 1419 if name == "spam": 1420 raise AttributeError 1421 return object.__setattr__(self, name, value) 1422 C.__setattr__ = mysetattr 1423 try: 1424 a.spam = "not spam" 1425 except AttributeError: 1426 pass 1427 else: 1428 self.fail("expected AttributeError") 1429 self.assertEqual(a.spam, "spam") 1430 class D(C): 1431 pass 1432 d = D() 1433 d.foo = 1 1434 self.assertEqual(d.foo, 1) 1435 1436 # Test handling of int*seq and seq*int 1437 class I(int): 1438 pass 1439 self.assertEqual("a"*I(2), "aa") 1440 self.assertEqual(I(2)*"a", "aa") 1441 self.assertEqual(2*I(3), 6) 1442 self.assertEqual(I(3)*2, 6) 1443 self.assertEqual(I(3)*I(2), 6) 1444 1445 # Test comparison of classes with dynamic metaclasses 1446 class dynamicmetaclass(type): 1447 pass 1448 class someclass(metaclass=dynamicmetaclass): 1449 pass 1450 self.assertNotEqual(someclass, object) 1451 1452 def test_errors(self): 1453 # Testing errors... 1454 try: 1455 class C(list, dict): 1456 pass 1457 except TypeError: 1458 pass 1459 else: 1460 self.fail("inheritance from both list and dict should be illegal") 1461 1462 try: 1463 class C(object, None): 1464 pass 1465 except TypeError: 1466 pass 1467 else: 1468 self.fail("inheritance from non-type should be illegal") 1469 class Classic: 1470 pass 1471 1472 try: 1473 class C(type(len)): 1474 pass 1475 except TypeError: 1476 pass 1477 else: 1478 self.fail("inheritance from CFunction should be illegal") 1479 1480 try: 1481 class C(object): 1482 __slots__ = 1 1483 except TypeError: 1484 pass 1485 else: 1486 self.fail("__slots__ = 1 should be illegal") 1487 1488 try: 1489 class C(object): 1490 __slots__ = [1] 1491 except TypeError: 1492 pass 1493 else: 1494 self.fail("__slots__ = [1] should be illegal") 1495 1496 class M1(type): 1497 pass 1498 class M2(type): 1499 pass 1500 class A1(object, metaclass=M1): 1501 pass 1502 class A2(object, metaclass=M2): 1503 pass 1504 try: 1505 class B(A1, A2): 1506 pass 1507 except TypeError: 1508 pass 1509 else: 1510 self.fail("finding the most derived metaclass should have failed") 1511 1512 def test_classmethods(self): 1513 # Testing class methods... 1514 class C(object): 1515 def foo(*a): return a 1516 goo = classmethod(foo) 1517 c = C() 1518 self.assertEqual(C.goo(1), (C, 1)) 1519 self.assertEqual(c.goo(1), (C, 1)) 1520 self.assertEqual(c.foo(1), (c, 1)) 1521 class D(C): 1522 pass 1523 d = D() 1524 self.assertEqual(D.goo(1), (D, 1)) 1525 self.assertEqual(d.goo(1), (D, 1)) 1526 self.assertEqual(d.foo(1), (d, 1)) 1527 self.assertEqual(D.foo(d, 1), (d, 1)) 1528 # Test for a specific crash (SF bug 528132) 1529 def f(cls, arg): return (cls, arg) 1530 ff = classmethod(f) 1531 self.assertEqual(ff.__get__(0, int)(42), (int, 42)) 1532 self.assertEqual(ff.__get__(0)(42), (int, 42)) 1533 1534 # Test super() with classmethods (SF bug 535444) 1535 self.assertEqual(C.goo.__self__, C) 1536 self.assertEqual(D.goo.__self__, D) 1537 self.assertEqual(super(D,D).goo.__self__, D) 1538 self.assertEqual(super(D,d).goo.__self__, D) 1539 self.assertEqual(super(D,D).goo(), (D,)) 1540 self.assertEqual(super(D,d).goo(), (D,)) 1541 1542 # Verify that a non-callable will raise 1543 meth = classmethod(1).__get__(1) 1544 self.assertRaises(TypeError, meth) 1545 1546 # Verify that classmethod() doesn't allow keyword args 1547 try: 1548 classmethod(f, kw=1) 1549 except TypeError: 1550 pass 1551 else: 1552 self.fail("classmethod shouldn't accept keyword args") 1553 1554 cm = classmethod(f) 1555 self.assertEqual(cm.__dict__, {}) 1556 cm.x = 42 1557 self.assertEqual(cm.x, 42) 1558 self.assertEqual(cm.__dict__, {"x" : 42}) 1559 del cm.x 1560 self.assertNotHasAttr(cm, "x") 1561 1562 @support.refcount_test 1563 def test_refleaks_in_classmethod___init__(self): 1564 gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount') 1565 cm = classmethod(None) 1566 refs_before = gettotalrefcount() 1567 for i in range(100): 1568 cm.__init__(None) 1569 self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10) 1570 1571 @support.impl_detail("the module 'xxsubtype' is internal") 1572 def test_classmethods_in_c(self): 1573 # Testing C-based class methods... 1574 import xxsubtype as spam 1575 a = (1, 2, 3) 1576 d = {'abc': 123} 1577 x, a1, d1 = spam.spamlist.classmeth(*a, **d) 1578 self.assertEqual(x, spam.spamlist) 1579 self.assertEqual(a, a1) 1580 self.assertEqual(d, d1) 1581 x, a1, d1 = spam.spamlist().classmeth(*a, **d) 1582 self.assertEqual(x, spam.spamlist) 1583 self.assertEqual(a, a1) 1584 self.assertEqual(d, d1) 1585 spam_cm = spam.spamlist.__dict__['classmeth'] 1586 x2, a2, d2 = spam_cm(spam.spamlist, *a, **d) 1587 self.assertEqual(x2, spam.spamlist) 1588 self.assertEqual(a2, a1) 1589 self.assertEqual(d2, d1) 1590 class SubSpam(spam.spamlist): pass 1591 x2, a2, d2 = spam_cm(SubSpam, *a, **d) 1592 self.assertEqual(x2, SubSpam) 1593 self.assertEqual(a2, a1) 1594 self.assertEqual(d2, d1) 1595 with self.assertRaises(TypeError): 1596 spam_cm() 1597 with self.assertRaises(TypeError): 1598 spam_cm(spam.spamlist()) 1599 with self.assertRaises(TypeError): 1600 spam_cm(list) 1601 1602 def test_staticmethods(self): 1603 # Testing static methods... 1604 class C(object): 1605 def foo(*a): return a 1606 goo = staticmethod(foo) 1607 c = C() 1608 self.assertEqual(C.goo(1), (1,)) 1609 self.assertEqual(c.goo(1), (1,)) 1610 self.assertEqual(c.foo(1), (c, 1,)) 1611 class D(C): 1612 pass 1613 d = D() 1614 self.assertEqual(D.goo(1), (1,)) 1615 self.assertEqual(d.goo(1), (1,)) 1616 self.assertEqual(d.foo(1), (d, 1)) 1617 self.assertEqual(D.foo(d, 1), (d, 1)) 1618 sm = staticmethod(None) 1619 self.assertEqual(sm.__dict__, {}) 1620 sm.x = 42 1621 self.assertEqual(sm.x, 42) 1622 self.assertEqual(sm.__dict__, {"x" : 42}) 1623 del sm.x 1624 self.assertNotHasAttr(sm, "x") 1625 1626 @support.refcount_test 1627 def test_refleaks_in_staticmethod___init__(self): 1628 gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount') 1629 sm = staticmethod(None) 1630 refs_before = gettotalrefcount() 1631 for i in range(100): 1632 sm.__init__(None) 1633 self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10) 1634 1635 @support.impl_detail("the module 'xxsubtype' is internal") 1636 def test_staticmethods_in_c(self): 1637 # Testing C-based static methods... 1638 import xxsubtype as spam 1639 a = (1, 2, 3) 1640 d = {"abc": 123} 1641 x, a1, d1 = spam.spamlist.staticmeth(*a, **d) 1642 self.assertEqual(x, None) 1643 self.assertEqual(a, a1) 1644 self.assertEqual(d, d1) 1645 x, a1, d2 = spam.spamlist().staticmeth(*a, **d) 1646 self.assertEqual(x, None) 1647 self.assertEqual(a, a1) 1648 self.assertEqual(d, d1) 1649 1650 def test_classic(self): 1651 # Testing classic classes... 1652 class C: 1653 def foo(*a): return a 1654 goo = classmethod(foo) 1655 c = C() 1656 self.assertEqual(C.goo(1), (C, 1)) 1657 self.assertEqual(c.goo(1), (C, 1)) 1658 self.assertEqual(c.foo(1), (c, 1)) 1659 class D(C): 1660 pass 1661 d = D() 1662 self.assertEqual(D.goo(1), (D, 1)) 1663 self.assertEqual(d.goo(1), (D, 1)) 1664 self.assertEqual(d.foo(1), (d, 1)) 1665 self.assertEqual(D.foo(d, 1), (d, 1)) 1666 class E: # *not* subclassing from C 1667 foo = C.foo 1668 self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound 1669 self.assertTrue(repr(C.foo.__get__(C())).startswith("<bound method ")) 1670 1671 def test_compattr(self): 1672 # Testing computed attributes... 1673 class C(object): 1674 class computed_attribute(object): 1675 def __init__(self, get, set=None, delete=None): 1676 self.__get = get 1677 self.__set = set 1678 self.__delete = delete 1679 def __get__(self, obj, type=None): 1680 return self.__get(obj) 1681 def __set__(self, obj, value): 1682 return self.__set(obj, value) 1683 def __delete__(self, obj): 1684 return self.__delete(obj) 1685 def __init__(self): 1686 self.__x = 0 1687 def __get_x(self): 1688 x = self.__x 1689 self.__x = x+1 1690 return x 1691 def __set_x(self, x): 1692 self.__x = x 1693 def __delete_x(self): 1694 del self.__x 1695 x = computed_attribute(__get_x, __set_x, __delete_x) 1696 a = C() 1697 self.assertEqual(a.x, 0) 1698 self.assertEqual(a.x, 1) 1699 a.x = 10 1700 self.assertEqual(a.x, 10) 1701 self.assertEqual(a.x, 11) 1702 del a.x 1703 self.assertNotHasAttr(a, 'x') 1704 1705 def test_newslots(self): 1706 # Testing __new__ slot override... 1707 class C(list): 1708 def __new__(cls): 1709 self = list.__new__(cls) 1710 self.foo = 1 1711 return self 1712 def __init__(self): 1713 self.foo = self.foo + 2 1714 a = C() 1715 self.assertEqual(a.foo, 3) 1716 self.assertEqual(a.__class__, C) 1717 class D(C): 1718 pass 1719 b = D() 1720 self.assertEqual(b.foo, 3) 1721 self.assertEqual(b.__class__, D) 1722 1723 @unittest.expectedFailure 1724 def test_bad_new(self): 1725 self.assertRaises(TypeError, object.__new__) 1726 self.assertRaises(TypeError, object.__new__, '') 1727 self.assertRaises(TypeError, list.__new__, object) 1728 self.assertRaises(TypeError, object.__new__, list) 1729 class C(object): 1730 __new__ = list.__new__ 1731 self.assertRaises(TypeError, C) 1732 class C(list): 1733 __new__ = object.__new__ 1734 self.assertRaises(TypeError, C) 1735 1736 def test_object_new(self): 1737 class A(object): 1738 pass 1739 object.__new__(A) 1740 self.assertRaises(TypeError, object.__new__, A, 5) 1741 object.__init__(A()) 1742 self.assertRaises(TypeError, object.__init__, A(), 5) 1743 1744 class A(object): 1745 def __init__(self, foo): 1746 self.foo = foo 1747 object.__new__(A) 1748 object.__new__(A, 5) 1749 object.__init__(A(3)) 1750 self.assertRaises(TypeError, object.__init__, A(3), 5) 1751 1752 class A(object): 1753 def __new__(cls, foo): 1754 return object.__new__(cls) 1755 object.__new__(A) 1756 self.assertRaises(TypeError, object.__new__, A, 5) 1757 object.__init__(A(3)) 1758 object.__init__(A(3), 5) 1759 1760 class A(object): 1761 def __new__(cls, foo): 1762 return object.__new__(cls) 1763 def __init__(self, foo): 1764 self.foo = foo 1765 object.__new__(A) 1766 self.assertRaises(TypeError, object.__new__, A, 5) 1767 object.__init__(A(3)) 1768 self.assertRaises(TypeError, object.__init__, A(3), 5) 1769 1770 @unittest.expectedFailure 1771 def test_restored_object_new(self): 1772 class A(object): 1773 def __new__(cls, *args, **kwargs): 1774 raise AssertionError 1775 self.assertRaises(AssertionError, A) 1776 class B(A): 1777 __new__ = object.__new__ 1778 def __init__(self, foo): 1779 self.foo = foo 1780 with warnings.catch_warnings(): 1781 warnings.simplefilter('error', DeprecationWarning) 1782 b = B(3) 1783 self.assertEqual(b.foo, 3) 1784 self.assertEqual(b.__class__, B) 1785 del B.__new__ 1786 self.assertRaises(AssertionError, B) 1787 del A.__new__ 1788 with warnings.catch_warnings(): 1789 warnings.simplefilter('error', DeprecationWarning) 1790 b = B(3) 1791 self.assertEqual(b.foo, 3) 1792 self.assertEqual(b.__class__, B) 1793 1794 def test_altmro(self): 1795 # Testing mro() and overriding it... 1796 class A(object): 1797 def f(self): return "A" 1798 class B(A): 1799 pass 1800 class C(A): 1801 def f(self): return "C" 1802 class D(B, C): 1803 pass 1804 self.assertEqual(A.mro(), [A, object]) 1805 self.assertEqual(A.__mro__, (A, object)) 1806 self.assertEqual(B.mro(), [B, A, object]) 1807 self.assertEqual(B.__mro__, (B, A, object)) 1808 self.assertEqual(C.mro(), [C, A, object]) 1809 self.assertEqual(C.__mro__, (C, A, object)) 1810 self.assertEqual(D.mro(), [D, B, C, A, object]) 1811 self.assertEqual(D.__mro__, (D, B, C, A, object)) 1812 self.assertEqual(D().f(), "C") 1813 1814 class PerverseMetaType(type): 1815 def mro(cls): 1816 L = type.mro(cls) 1817 L.reverse() 1818 return L 1819 class X(D,B,C,A, metaclass=PerverseMetaType): 1820 pass 1821 self.assertEqual(X.__mro__, (object, A, C, B, D, X)) 1822 self.assertEqual(X().f(), "A") 1823 1824 try: 1825 class _metaclass(type): 1826 def mro(self): 1827 return [self, dict, object] 1828 class X(object, metaclass=_metaclass): 1829 pass 1830 # In CPython, the class creation above already raises 1831 # TypeError, as a protection against the fact that 1832 # instances of X would segfault it. In other Python 1833 # implementations it would be ok to let the class X 1834 # be created, but instead get a clean TypeError on the 1835 # __setitem__ below. 1836 x = object.__new__(X) 1837 x[5] = 6 1838 except TypeError: 1839 pass 1840 else: 1841 self.fail("devious mro() return not caught") 1842 1843 try: 1844 class _metaclass(type): 1845 def mro(self): 1846 return [1] 1847 class X(object, metaclass=_metaclass): 1848 pass 1849 except TypeError: 1850 pass 1851 else: 1852 self.fail("non-class mro() return not caught") 1853 1854 try: 1855 class _metaclass(type): 1856 def mro(self): 1857 return 1 1858 class X(object, metaclass=_metaclass): 1859 pass 1860 except TypeError: 1861 pass 1862 else: 1863 self.fail("non-sequence mro() return not caught") 1864 1865 def test_overloading(self): 1866 # Testing operator overloading... 1867 1868 class B(object): 1869 "Intermediate class because object doesn't have a __setattr__" 1870 1871 class C(B): 1872 def __getattr__(self, name): 1873 if name == "foo": 1874 return ("getattr", name) 1875 else: 1876 raise AttributeError 1877 def __setattr__(self, name, value): 1878 if name == "foo": 1879 self.setattr = (name, value) 1880 else: 1881 return B.__setattr__(self, name, value) 1882 def __delattr__(self, name): 1883 if name == "foo": 1884 self.delattr = name 1885 else: 1886 return B.__delattr__(self, name) 1887 1888 def __getitem__(self, key): 1889 return ("getitem", key) 1890 def __setitem__(self, key, value): 1891 self.setitem = (key, value) 1892 def __delitem__(self, key): 1893 self.delitem = key 1894 1895 a = C() 1896 self.assertEqual(a.foo, ("getattr", "foo")) 1897 a.foo = 12 1898 self.assertEqual(a.setattr, ("foo", 12)) 1899 del a.foo 1900 self.assertEqual(a.delattr, "foo") 1901 1902 self.assertEqual(a[12], ("getitem", 12)) 1903 a[12] = 21 1904 self.assertEqual(a.setitem, (12, 21)) 1905 del a[12] 1906 self.assertEqual(a.delitem, 12) 1907 1908 self.assertEqual(a[0:10], ("getitem", slice(0, 10))) 1909 a[0:10] = "foo" 1910 self.assertEqual(a.setitem, (slice(0, 10), "foo")) 1911 del a[0:10] 1912 self.assertEqual(a.delitem, (slice(0, 10))) 1913 1914 def test_methods(self): 1915 # Testing methods... 1916 class C(object): 1917 def __init__(self, x): 1918 self.x = x 1919 def foo(self): 1920 return self.x 1921 c1 = C(1) 1922 self.assertEqual(c1.foo(), 1) 1923 class D(C): 1924 boo = C.foo 1925 goo = c1.foo 1926 d2 = D(2) 1927 self.assertEqual(d2.foo(), 2) 1928 self.assertEqual(d2.boo(), 2) 1929 self.assertEqual(d2.goo(), 1) 1930 class E(object): 1931 foo = C.foo 1932 self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound 1933 self.assertTrue(repr(C.foo.__get__(C(1))).startswith("<bound method ")) 1934 1935 def test_special_method_lookup(self): 1936 # The lookup of special methods bypasses __getattr__ and 1937 # __getattribute__, but they still can be descriptors. 1938 1939 def run_context(manager): 1940 with manager: 1941 pass 1942 def iden(self): 1943 return self 1944 def hello(self): 1945 return b"hello" 1946 def empty_seq(self): 1947 return [] 1948 def zero(self): 1949 return 0 1950 def complex_num(self): 1951 return 1j 1952 def stop(self): 1953 raise StopIteration 1954 def return_true(self, thing=None): 1955 return True 1956 def do_isinstance(obj): 1957 return isinstance(int, obj) 1958 def do_issubclass(obj): 1959 return issubclass(int, obj) 1960 def do_dict_missing(checker): 1961 class DictSub(checker.__class__, dict): 1962 pass 1963 self.assertEqual(DictSub()["hi"], 4) 1964 def some_number(self_, key): 1965 self.assertEqual(key, "hi") 1966 return 4 1967 def swallow(*args): pass 1968 def format_impl(self, spec): 1969 return "hello" 1970 1971 # It would be nice to have every special method tested here, but I'm 1972 # only listing the ones I can remember outside of typeobject.c, since it 1973 # does it right. 1974 specials = [ 1975 ("__bytes__", bytes, hello, set(), {}), 1976 ("__reversed__", reversed, empty_seq, set(), {}), 1977 ("__length_hint__", list, zero, set(), 1978 {"__iter__" : iden, "__next__" : stop}), 1979 ("__sizeof__", sys.getsizeof, zero, set(), {}), 1980 ("__instancecheck__", do_isinstance, return_true, set(), {}), 1981 ("__missing__", do_dict_missing, some_number, 1982 set(("__class__",)), {}), 1983 ("__subclasscheck__", do_issubclass, return_true, 1984 set(("__bases__",)), {}), 1985 ("__enter__", run_context, iden, set(), {"__exit__" : swallow}), 1986 ("__exit__", run_context, swallow, set(), {"__enter__" : iden}), 1987 ("__complex__", complex, complex_num, set(), {}), 1988 ("__format__", format, format_impl, set(), {}), 1989 ("__floor__", math.floor, zero, set(), {}), 1990 ("__trunc__", math.trunc, zero, set(), {}), 1991 ("__trunc__", int, zero, set(), {}), 1992 ("__ceil__", math.ceil, zero, set(), {}), 1993 ("__dir__", dir, empty_seq, set(), {}), 1994 ("__round__", round, zero, set(), {}), 1995 ] 1996 1997 class Checker(object): 1998 def __getattr__(self, attr, test=self): 1999 test.fail("__getattr__ called with {0}".format(attr)) 2000 def __getattribute__(self, attr, test=self): 2001 if attr not in ok: 2002 test.fail("__getattribute__ called with {0}".format(attr)) 2003 return object.__getattribute__(self, attr) 2004 class SpecialDescr(object): 2005 def __init__(self, impl): 2006 self.impl = impl 2007 def __get__(self, obj, owner): 2008 record.append(1) 2009 return self.impl.__get__(obj, owner) 2010 class MyException(Exception): 2011 pass 2012 class ErrDescr(object): 2013 def __get__(self, obj, owner): 2014 raise MyException 2015 2016 for name, runner, meth_impl, ok, env in specials: 2017 class X(Checker): 2018 pass 2019 for attr, obj in env.items(): 2020 setattr(X, attr, obj) 2021 setattr(X, name, meth_impl) 2022 runner(X()) 2023 2024 record = [] 2025 class X(Checker): 2026 pass 2027 for attr, obj in env.items(): 2028 setattr(X, attr, obj) 2029 setattr(X, name, SpecialDescr(meth_impl)) 2030 runner(X()) 2031 self.assertEqual(record, [1], name) 2032 2033 class X(Checker): 2034 pass 2035 for attr, obj in env.items(): 2036 setattr(X, attr, obj) 2037 setattr(X, name, ErrDescr()) 2038 self.assertRaises(MyException, runner, X()) 2039 2040 def test_specials(self): 2041 # Testing special operators... 2042 # Test operators like __hash__ for which a built-in default exists 2043 2044 # Test the default behavior for static classes 2045 class C(object): 2046 def __getitem__(self, i): 2047 if 0 <= i < 10: return i 2048 raise IndexError 2049 c1 = C() 2050 c2 = C() 2051 self.assertFalse(not c1) 2052 self.assertNotEqual(id(c1), id(c2)) 2053 hash(c1) 2054 hash(c2) 2055 self.assertEqual(c1, c1) 2056 self.assertTrue(c1 != c2) 2057 self.assertFalse(c1 != c1) 2058 self.assertFalse(c1 == c2) 2059 # Note that the module name appears in str/repr, and that varies 2060 # depending on whether this test is run standalone or from a framework. 2061 self.assertGreaterEqual(str(c1).find('C object at '), 0) 2062 self.assertEqual(str(c1), repr(c1)) 2063 self.assertNotIn(-1, c1) 2064 for i in range(10): 2065 self.assertIn(i, c1) 2066 self.assertNotIn(10, c1) 2067 # Test the default behavior for dynamic classes 2068 class D(object): 2069 def __getitem__(self, i): 2070 if 0 <= i < 10: return i 2071 raise IndexError 2072 d1 = D() 2073 d2 = D() 2074 self.assertFalse(not d1) 2075 self.assertNotEqual(id(d1), id(d2)) 2076 hash(d1) 2077 hash(d2) 2078 self.assertEqual(d1, d1) 2079 self.assertNotEqual(d1, d2) 2080 self.assertFalse(d1 != d1) 2081 self.assertFalse(d1 == d2) 2082 # Note that the module name appears in str/repr, and that varies 2083 # depending on whether this test is run standalone or from a framework. 2084 self.assertGreaterEqual(str(d1).find('D object at '), 0) 2085 self.assertEqual(str(d1), repr(d1)) 2086 self.assertNotIn(-1, d1) 2087 for i in range(10): 2088 self.assertIn(i, d1) 2089 self.assertNotIn(10, d1) 2090 # Test overridden behavior 2091 class Proxy(object): 2092 def __init__(self, x): 2093 self.x = x 2094 def __bool__(self): 2095 return not not self.x 2096 def __hash__(self): 2097 return hash(self.x) 2098 def __eq__(self, other): 2099 return self.x == other 2100 def __ne__(self, other): 2101 return self.x != other 2102 def __ge__(self, other): 2103 return self.x >= other 2104 def __gt__(self, other): 2105 return self.x > other 2106 def __le__(self, other): 2107 return self.x <= other 2108 def __lt__(self, other): 2109 return self.x < other 2110 def __str__(self): 2111 return "Proxy:%s" % self.x 2112 def __repr__(self): 2113 return "Proxy(%r)" % self.x 2114 def __contains__(self, value): 2115 return value in self.x 2116 p0 = Proxy(0) 2117 p1 = Proxy(1) 2118 p_1 = Proxy(-1) 2119 self.assertFalse(p0) 2120 self.assertFalse(not p1) 2121 self.assertEqual(hash(p0), hash(0)) 2122 self.assertEqual(p0, p0) 2123 self.assertNotEqual(p0, p1) 2124 self.assertFalse(p0 != p0) 2125 self.assertEqual(not p0, p1) 2126 self.assertTrue(p0 < p1) 2127 self.assertTrue(p0 <= p1) 2128 self.assertTrue(p1 > p0) 2129 self.assertTrue(p1 >= p0) 2130 self.assertEqual(str(p0), "Proxy:0") 2131 self.assertEqual(repr(p0), "Proxy(0)") 2132 p10 = Proxy(range(10)) 2133 self.assertNotIn(-1, p10) 2134 for i in range(10): 2135 self.assertIn(i, p10) 2136 self.assertNotIn(10, p10) 2137 2138 def test_weakrefs(self): 2139 # Testing weak references... 2140 import weakref 2141 class C(object): 2142 pass 2143 c = C() 2144 r = weakref.ref(c) 2145 self.assertEqual(r(), c) 2146 del c 2147 support.gc_collect() 2148 self.assertEqual(r(), None) 2149 del r 2150 class NoWeak(object): 2151 __slots__ = ['foo'] 2152 no = NoWeak() 2153 try: 2154 weakref.ref(no) 2155 except TypeError as msg: 2156 self.assertIn("weak reference", str(msg)) 2157 else: 2158 self.fail("weakref.ref(no) should be illegal") 2159 class Weak(object): 2160 __slots__ = ['foo', '__weakref__'] 2161 yes = Weak() 2162 r = weakref.ref(yes) 2163 self.assertEqual(r(), yes) 2164 del yes 2165 support.gc_collect() 2166 self.assertEqual(r(), None) 2167 del r 2168 2169 def test_properties(self): 2170 # Testing property... 2171 class C(object): 2172 def getx(self): 2173 return self.__x 2174 def setx(self, value): 2175 self.__x = value 2176 def delx(self): 2177 del self.__x 2178 x = property(getx, setx, delx, doc="I'm the x property.") 2179 a = C() 2180 self.assertNotHasAttr(a, "x") 2181 a.x = 42 2182 self.assertEqual(a._C__x, 42) 2183 self.assertEqual(a.x, 42) 2184 del a.x 2185 self.assertNotHasAttr(a, "x") 2186 self.assertNotHasAttr(a, "_C__x") 2187 C.x.__set__(a, 100) 2188 self.assertEqual(C.x.__get__(a), 100) 2189 C.x.__delete__(a) 2190 self.assertNotHasAttr(a, "x") 2191 2192 raw = C.__dict__['x'] 2193 self.assertIsInstance(raw, property) 2194 2195 attrs = dir(raw) 2196 self.assertIn("__doc__", attrs) 2197 self.assertIn("fget", attrs) 2198 self.assertIn("fset", attrs) 2199 self.assertIn("fdel", attrs) 2200 2201 self.assertEqual(raw.__doc__, "I'm the x property.") 2202 self.assertIs(raw.fget, C.__dict__['getx']) 2203 self.assertIs(raw.fset, C.__dict__['setx']) 2204 self.assertIs(raw.fdel, C.__dict__['delx']) 2205 2206 for attr in "fget", "fset", "fdel": 2207 try: 2208 setattr(raw, attr, 42) 2209 except AttributeError as msg: 2210 if str(msg).find('readonly') < 0: 2211 self.fail("when setting readonly attr %r on a property, " 2212 "got unexpected AttributeError msg %r" % (attr, str(msg))) 2213 else: 2214 self.fail("expected AttributeError from trying to set readonly %r " 2215 "attr on a property" % attr) 2216 2217 raw.__doc__ = 42 2218 self.assertEqual(raw.__doc__, 42) 2219 2220 class D(object): 2221 __getitem__ = property(lambda s: 1/0) 2222 2223 d = D() 2224 try: 2225 for i in d: 2226 str(i) 2227 except ZeroDivisionError: 2228 pass 2229 else: 2230 self.fail("expected ZeroDivisionError from bad property") 2231 2232 @unittest.skipIf(sys.flags.optimize >= 2, 2233 "Docstrings are omitted with -O2 and above") 2234 def test_properties_doc_attrib(self): 2235 class E(object): 2236 def getter(self): 2237 "getter method" 2238 return 0 2239 def setter(self_, value): 2240 "setter method" 2241 pass 2242 prop = property(getter) 2243 self.assertEqual(prop.__doc__, "getter method") 2244 prop2 = property(fset=setter) 2245 self.assertEqual(prop2.__doc__, None) 2246 2247 @support.cpython_only 2248 def test_testcapi_no_segfault(self): 2249 # this segfaulted in 2.5b2 2250 try: 2251 import _testcapi 2252 except ImportError: 2253 pass 2254 else: 2255 class X(object): 2256 p = property(_testcapi.test_with_docstring) 2257 2258 def test_properties_plus(self): 2259 class C(object): 2260 foo = property(doc="hello") 2261 @foo.getter 2262 def foo(self): 2263 return self._foo 2264 @foo.setter 2265 def foo(self, value): 2266 self._foo = abs(value) 2267 @foo.deleter 2268 def foo(self): 2269 del self._foo 2270 c = C() 2271 self.assertEqual(C.foo.__doc__, "hello") 2272 self.assertNotHasAttr(c, "foo") 2273 c.foo = -42 2274 self.assertHasAttr(c, '_foo') 2275 self.assertEqual(c._foo, 42) 2276 self.assertEqual(c.foo, 42) 2277 del c.foo 2278 self.assertNotHasAttr(c, '_foo') 2279 self.assertNotHasAttr(c, "foo") 2280 2281 class D(C): 2282 @C.foo.deleter 2283 def foo(self): 2284 try: 2285 del self._foo 2286 except AttributeError: 2287 pass 2288 d = D() 2289 d.foo = 24 2290 self.assertEqual(d.foo, 24) 2291 del d.foo 2292 del d.foo 2293 2294 class E(object): 2295 @property 2296 def foo(self): 2297 return self._foo 2298 @foo.setter 2299 def foo(self, value): 2300 raise RuntimeError 2301 @foo.setter 2302 def foo(self, value): 2303 self._foo = abs(value) 2304 @foo.deleter 2305 def foo(self, value=None): 2306 del self._foo 2307 2308 e = E() 2309 e.foo = -42 2310 self.assertEqual(e.foo, 42) 2311 del e.foo 2312 2313 class F(E): 2314 @E.foo.deleter 2315 def foo(self): 2316 del self._foo 2317 @foo.setter 2318 def foo(self, value): 2319 self._foo = max(0, value) 2320 f = F() 2321 f.foo = -10 2322 self.assertEqual(f.foo, 0) 2323 del f.foo 2324 2325 def test_dict_constructors(self): 2326 # Testing dict constructor ... 2327 d = dict() 2328 self.assertEqual(d, {}) 2329 d = dict({}) 2330 self.assertEqual(d, {}) 2331 d = dict({1: 2, 'a': 'b'}) 2332 self.assertEqual(d, {1: 2, 'a': 'b'}) 2333 self.assertEqual(d, dict(list(d.items()))) 2334 self.assertEqual(d, dict(iter(d.items()))) 2335 d = dict({'one':1, 'two':2}) 2336 self.assertEqual(d, dict(one=1, two=2)) 2337 self.assertEqual(d, dict(**d)) 2338 self.assertEqual(d, dict({"one": 1}, two=2)) 2339 self.assertEqual(d, dict([("two", 2)], one=1)) 2340 self.assertEqual(d, dict([("one", 100), ("two", 200)], **d)) 2341 self.assertEqual(d, dict(**d)) 2342 2343 for badarg in 0, 0, 0j, "0", [0], (0,): 2344 try: 2345 dict(badarg) 2346 except TypeError: 2347 pass 2348 except ValueError: 2349 if badarg == "0": 2350 # It's a sequence, and its elements are also sequences (gotta 2351 # love strings <wink>), but they aren't of length 2, so this 2352 # one seemed better as a ValueError than a TypeError. 2353 pass 2354 else: 2355 self.fail("no TypeError from dict(%r)" % badarg) 2356 else: 2357 self.fail("no TypeError from dict(%r)" % badarg) 2358 2359 try: 2360 dict({}, {}) 2361 except TypeError: 2362 pass 2363 else: 2364 self.fail("no TypeError from dict({}, {})") 2365 2366 class Mapping: 2367 # Lacks a .keys() method; will be added later. 2368 dict = {1:2, 3:4, 'a':1j} 2369 2370 try: 2371 dict(Mapping()) 2372 except TypeError: 2373 pass 2374 else: 2375 self.fail("no TypeError from dict(incomplete mapping)") 2376 2377 Mapping.keys = lambda self: list(self.dict.keys()) 2378 Mapping.__getitem__ = lambda self, i: self.dict[i] 2379 d = dict(Mapping()) 2380 self.assertEqual(d, Mapping.dict) 2381 2382 # Init from sequence of iterable objects, each producing a 2-sequence. 2383 class AddressBookEntry: 2384 def __init__(self, first, last): 2385 self.first = first 2386 self.last = last 2387 def __iter__(self): 2388 return iter([self.first, self.last]) 2389 2390 d = dict([AddressBookEntry('Tim', 'Warsaw'), 2391 AddressBookEntry('Barry', 'Peters'), 2392 AddressBookEntry('Tim', 'Peters'), 2393 AddressBookEntry('Barry', 'Warsaw')]) 2394 self.assertEqual(d, {'Barry': 'Warsaw', 'Tim': 'Peters'}) 2395 2396 d = dict(zip(range(4), range(1, 5))) 2397 self.assertEqual(d, dict([(i, i+1) for i in range(4)])) 2398 2399 # Bad sequence lengths. 2400 for bad in [('tooshort',)], [('too', 'long', 'by 1')]: 2401 try: 2402 dict(bad) 2403 except ValueError: 2404 pass 2405 else: 2406 self.fail("no ValueError from dict(%r)" % bad) 2407 2408 def test_dir(self): 2409 # Testing dir() ... 2410 junk = 12 2411 self.assertEqual(dir(), ['junk', 'self']) 2412 del junk 2413 2414 # Just make sure these don't blow up! 2415 for arg in 2, 2, 2j, 2e0, [2], "2", b"2", (2,), {2:2}, type, self.test_dir: 2416 dir(arg) 2417 2418 # Test dir on new-style classes. Since these have object as a 2419 # base class, a lot more gets sucked in. 2420 def interesting(strings): 2421 return [s for s in strings if not s.startswith('_')] 2422 2423 class C(object): 2424 Cdata = 1 2425 def Cmethod(self): pass 2426 2427 cstuff = ['Cdata', 'Cmethod'] 2428 self.assertEqual(interesting(dir(C)), cstuff) 2429 2430 c = C() 2431 self.assertEqual(interesting(dir(c)), cstuff) 2432 ## self.assertIn('__self__', dir(C.Cmethod)) 2433 2434 c.cdata = 2 2435 c.cmethod = lambda self: 0 2436 self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod']) 2437 ## self.assertIn('__self__', dir(c.Cmethod)) 2438 2439 class A(C): 2440 Adata = 1 2441 def Amethod(self): pass 2442 2443 astuff = ['Adata', 'Amethod'] + cstuff 2444 self.assertEqual(interesting(dir(A)), astuff) 2445 ## self.assertIn('__self__', dir(A.Amethod)) 2446 a = A() 2447 self.assertEqual(interesting(dir(a)), astuff) 2448 a.adata = 42 2449 a.amethod = lambda self: 3 2450 self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod']) 2451 ## self.assertIn('__self__', dir(a.Amethod)) 2452 2453 # Try a module subclass. 2454 class M(type(sys)): 2455 pass 2456 minstance = M("m") 2457 minstance.b = 2 2458 minstance.a = 1 2459 default_attributes = ['__name__', '__doc__', '__package__', 2460 '__loader__', '__spec__'] 2461 names = [x for x in dir(minstance) if x not in default_attributes] 2462 self.assertEqual(names, ['a', 'b']) 2463 2464 class M2(M): 2465 def getdict(self): 2466 return "Not a dict!" 2467 __dict__ = property(getdict) 2468 2469 m2instance = M2("m2") 2470 m2instance.b = 2 2471 m2instance.a = 1 2472 self.assertEqual(m2instance.__dict__, "Not a dict!") 2473 try: 2474 dir(m2instance) 2475 except TypeError: 2476 pass 2477 2478 # Two essentially featureless objects, just inheriting stuff from 2479 # object. 2480 self.assertEqual(dir(NotImplemented), dir(Ellipsis)) 2481 2482 # Nasty test case for proxied objects 2483 class Wrapper(object): 2484 def __init__(self, obj): 2485 self.__obj = obj 2486 def __repr__(self): 2487 return "Wrapper(%s)" % repr(self.__obj) 2488 def __getitem__(self, key): 2489 return Wrapper(self.__obj[key]) 2490 def __len__(self): 2491 return len(self.__obj) 2492 def __getattr__(self, name): 2493 return Wrapper(getattr(self.__obj, name)) 2494 2495 class C(object): 2496 def __getclass(self): 2497 return Wrapper(type(self)) 2498 __class__ = property(__getclass) 2499 2500 dir(C()) # This used to segfault 2501 2502 def test_supers(self): 2503 # Testing super... 2504 2505 class A(object): 2506 def meth(self, a): 2507 return "A(%r)" % a 2508 2509 self.assertEqual(A().meth(1), "A(1)") 2510 2511 class B(A): 2512 def __init__(self): 2513 self.__super = super(B, self) 2514 def meth(self, a): 2515 return "B(%r)" % a + self.__super.meth(a) 2516 2517 self.assertEqual(B().meth(2), "B(2)A(2)") 2518 2519 class C(A): 2520 def meth(self, a): 2521 return "C(%r)" % a + self.__super.meth(a) 2522 C._C__super = super(C) 2523 2524 self.assertEqual(C().meth(3), "C(3)A(3)") 2525 2526 class D(C, B): 2527 def meth(self, a): 2528 return "D(%r)" % a + super(D, self).meth(a) 2529 2530 self.assertEqual(D().meth(4), "D(4)C(4)B(4)A(4)") 2531 2532 # Test for subclassing super 2533 2534 class mysuper(super): 2535 def __init__(self, *args): 2536 return super(mysuper, self).__init__(*args) 2537 2538 class E(D): 2539 def meth(self, a): 2540 return "E(%r)" % a + mysuper(E, self).meth(a) 2541 2542 self.assertEqual(E().meth(5), "E(5)D(5)C(5)B(5)A(5)") 2543 2544 class F(E): 2545 def meth(self, a): 2546 s = self.__super # == mysuper(F, self) 2547 return "F(%r)[%s]" % (a, s.__class__.__name__) + s.meth(a) 2548 F._F__super = mysuper(F) 2549 2550 self.assertEqual(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)") 2551 2552 # Make sure certain errors are raised 2553 2554 try: 2555 super(D, 42) 2556 except TypeError: 2557 pass 2558 else: 2559 self.fail("shouldn't allow super(D, 42)") 2560 2561 try: 2562 super(D, C()) 2563 except TypeError: 2564 pass 2565 else: 2566 self.fail("shouldn't allow super(D, C())") 2567 2568 try: 2569 super(D).__get__(12) 2570 except TypeError: 2571 pass 2572 else: 2573 self.fail("shouldn't allow super(D).__get__(12)") 2574 2575 try: 2576 super(D).__get__(C()) 2577 except TypeError: 2578 pass 2579 else: 2580 self.fail("shouldn't allow super(D).__get__(C())") 2581 2582 # Make sure data descriptors can be overridden and accessed via super 2583 # (new feature in Python 2.3) 2584 2585 class DDbase(object): 2586 def getx(self): return 42 2587 x = property(getx) 2588 2589 class DDsub(DDbase): 2590 def getx(self): return "hello" 2591 x = property(getx) 2592 2593 dd = DDsub() 2594 self.assertEqual(dd.x, "hello") 2595 self.assertEqual(super(DDsub, dd).x, 42) 2596 2597 # Ensure that super() lookup of descriptor from classmethod 2598 # works (SF ID# 743627) 2599 2600 class Base(object): 2601 aProp = property(lambda self: "foo") 2602 2603 class Sub(Base): 2604 @classmethod 2605 def test(klass): 2606 return super(Sub,klass).aProp 2607 2608 self.assertEqual(Sub.test(), Base.aProp) 2609 2610 # Verify that super() doesn't allow keyword args 2611 try: 2612 super(Base, kw=1) 2613 except TypeError: 2614 pass 2615 else: 2616 self.assertEqual("super shouldn't accept keyword args") 2617 2618 def test_basic_inheritance(self): 2619 # Testing inheritance from basic types... 2620 2621 class hexint(int): 2622 def __repr__(self): 2623 return hex(self) 2624 def __add__(self, other): 2625 return hexint(int.__add__(self, other)) 2626 # (Note that overriding __radd__ doesn't work, 2627 # because the int type gets first dibs.) 2628 self.assertEqual(repr(hexint(7) + 9), "0x10") 2629 self.assertEqual(repr(hexint(1000) + 7), "0x3ef") 2630 a = hexint(12345) 2631 self.assertEqual(a, 12345) 2632 self.assertEqual(int(a), 12345) 2633 self.assertIs(int(a).__class__, int) 2634 self.assertEqual(hash(a), hash(12345)) 2635 self.assertIs((+a).__class__, int) 2636 self.assertIs((a >> 0).__class__, int) 2637 self.assertIs((a << 0).__class__, int) 2638 self.assertIs((hexint(0) << 12).__class__, int) 2639 self.assertIs((hexint(0) >> 12).__class__, int) 2640 2641 class octlong(int): 2642 __slots__ = [] 2643 def __str__(self): 2644 return oct(self) 2645 def __add__(self, other): 2646 return self.__class__(super(octlong, self).__add__(other)) 2647 __radd__ = __add__ 2648 self.assertEqual(str(octlong(3) + 5), "0o10") 2649 # (Note that overriding __radd__ here only seems to work 2650 # because the example uses a short int left argument.) 2651 self.assertEqual(str(5 + octlong(3000)), "0o5675") 2652 a = octlong(12345) 2653 self.assertEqual(a, 12345) 2654 self.assertEqual(int(a), 12345) 2655 self.assertEqual(hash(a), hash(12345)) 2656 self.assertIs(int(a).__class__, int) 2657 self.assertIs((+a).__class__, int) 2658 self.assertIs((-a).__class__, int) 2659 self.assertIs((-octlong(0)).__class__, int) 2660 self.assertIs((a >> 0).__class__, int) 2661 self.assertIs((a << 0).__class__, int) 2662 self.assertIs((a - 0).__class__, int) 2663 self.assertIs((a * 1).__class__, int) 2664 self.assertIs((a ** 1).__class__, int) 2665 self.assertIs((a // 1).__class__, int) 2666 self.assertIs((1 * a).__class__, int) 2667 self.assertIs((a | 0).__class__, int) 2668 self.assertIs((a ^ 0).__class__, int) 2669 self.assertIs((a & -1).__class__, int) 2670 self.assertIs((octlong(0) << 12).__class__, int) 2671 self.assertIs((octlong(0) >> 12).__class__, int) 2672 self.assertIs(abs(octlong(0)).__class__, int) 2673 2674 # Because octlong overrides __add__, we can't check the absence of +0 2675 # optimizations using octlong. 2676 class longclone(int): 2677 pass 2678 a = longclone(1) 2679 self.assertIs((a + 0).__class__, int) 2680 self.assertIs((0 + a).__class__, int) 2681 2682 # Check that negative clones don't segfault 2683 a = longclone(-1) 2684 self.assertEqual(a.__dict__, {}) 2685 self.assertEqual(int(a), -1) # self.assertTrue PyNumber_Long() copies the sign bit 2686 2687 class precfloat(float): 2688 __slots__ = ['prec'] 2689 def __init__(self, value=0.0, prec=12): 2690 self.prec = int(prec) 2691 def __repr__(self): 2692 return "%.*g" % (self.prec, self) 2693 self.assertEqual(repr(precfloat(1.1)), "1.1") 2694 a = precfloat(12345) 2695 self.assertEqual(a, 12345.0) 2696 self.assertEqual(float(a), 12345.0) 2697 self.assertIs(float(a).__class__, float) 2698 self.assertEqual(hash(a), hash(12345.0)) 2699 self.assertIs((+a).__class__, float) 2700 2701 class madcomplex(complex): 2702 def __repr__(self): 2703 return "%.17gj%+.17g" % (self.imag, self.real) 2704 a = madcomplex(-3, 4) 2705 self.assertEqual(repr(a), "4j-3") 2706 base = complex(-3, 4) 2707 self.assertEqual(base.__class__, complex) 2708 self.assertEqual(a, base) 2709 self.assertEqual(complex(a), base) 2710 self.assertEqual(complex(a).__class__, complex) 2711 a = madcomplex(a) # just trying another form of the constructor 2712 self.assertEqual(repr(a), "4j-3") 2713 self.assertEqual(a, base) 2714 self.assertEqual(complex(a), base) 2715 self.assertEqual(complex(a).__class__, complex) 2716 self.assertEqual(hash(a), hash(base)) 2717 self.assertEqual((+a).__class__, complex) 2718 self.assertEqual((a + 0).__class__, complex) 2719 self.assertEqual(a + 0, base) 2720 self.assertEqual((a - 0).__class__, complex) 2721 self.assertEqual(a - 0, base) 2722 self.assertEqual((a * 1).__class__, complex) 2723 self.assertEqual(a * 1, base) 2724 self.assertEqual((a / 1).__class__, complex) 2725 self.assertEqual(a / 1, base) 2726 2727 class madtuple(tuple): 2728 _rev = None 2729 def rev(self): 2730 if self._rev is not None: 2731 return self._rev 2732 L = list(self) 2733 L.reverse() 2734 self._rev = self.__class__(L) 2735 return self._rev 2736 a = madtuple((1,2,3,4,5,6,7,8,9,0)) 2737 self.assertEqual(a, (1,2,3,4,5,6,7,8,9,0)) 2738 self.assertEqual(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1))) 2739 self.assertEqual(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0))) 2740 for i in range(512): 2741 t = madtuple(range(i)) 2742 u = t.rev() 2743 v = u.rev() 2744 self.assertEqual(v, t) 2745 a = madtuple((1,2,3,4,5)) 2746 self.assertEqual(tuple(a), (1,2,3,4,5)) 2747 self.assertIs(tuple(a).__class__, tuple) 2748 self.assertEqual(hash(a), hash((1,2,3,4,5))) 2749 self.assertIs(a[:].__class__, tuple) 2750 self.assertIs((a * 1).__class__, tuple) 2751 self.assertIs((a * 0).__class__, tuple) 2752 self.assertIs((a + ()).__class__, tuple) 2753 a = madtuple(()) 2754 self.assertEqual(tuple(a), ()) 2755 self.assertIs(tuple(a).__class__, tuple) 2756 self.assertIs((a + a).__class__, tuple) 2757 self.assertIs((a * 0).__class__, tuple) 2758 self.assertIs((a * 1).__class__, tuple) 2759 self.assertIs((a * 2).__class__, tuple) 2760 self.assertIs(a[:].__class__, tuple) 2761 2762 class madstring(str): 2763 _rev = None 2764 def rev(self): 2765 if self._rev is not None: 2766 return self._rev 2767 L = list(self) 2768 L.reverse() 2769 self._rev = self.__class__("".join(L)) 2770 return self._rev 2771 s = madstring("abcdefghijklmnopqrstuvwxyz") 2772 self.assertEqual(s, "abcdefghijklmnopqrstuvwxyz") 2773 self.assertEqual(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba")) 2774 self.assertEqual(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz")) 2775 for i in range(256): 2776 s = madstring("".join(map(chr, range(i)))) 2777 t = s.rev() 2778 u = t.rev() 2779 self.assertEqual(u, s) 2780 s = madstring("12345") 2781 self.assertEqual(str(s), "12345") 2782 self.assertIs(str(s).__class__, str) 2783 2784 base = "\x00" * 5 2785 s = madstring(base) 2786 self.assertEqual(s, base) 2787 self.assertEqual(str(s), base) 2788 self.assertIs(str(s).__class__, str) 2789 self.assertEqual(hash(s), hash(base)) 2790 self.assertEqual({s: 1}[base], 1) 2791 self.assertEqual({base: 1}[s], 1) 2792 self.assertIs((s + "").__class__, str) 2793 self.assertEqual(s + "", base) 2794 self.assertIs(("" + s).__class__, str) 2795 self.assertEqual("" + s, base) 2796 self.assertIs((s * 0).__class__, str) 2797 self.assertEqual(s * 0, "") 2798 self.assertIs((s * 1).__class__, str) 2799 self.assertEqual(s * 1, base) 2800 self.assertIs((s * 2).__class__, str) 2801 self.assertEqual(s * 2, base + base) 2802 self.assertIs(s[:].__class__, str) 2803 self.assertEqual(s[:], base) 2804 self.assertIs(s[0:0].__class__, str) 2805 self.assertEqual(s[0:0], "") 2806 self.assertIs(s.strip().__class__, str) 2807 self.assertEqual(s.strip(), base) 2808 self.assertIs(s.lstrip().__class__, str) 2809 self.assertEqual(s.lstrip(), base) 2810 self.assertIs(s.rstrip().__class__, str) 2811 self.assertEqual(s.rstrip(), base) 2812 identitytab = {} 2813 self.assertIs(s.translate(identitytab).__class__, str) 2814 self.assertEqual(s.translate(identitytab), base) 2815 self.assertIs(s.replace("x", "x").__class__, str) 2816 self.assertEqual(s.replace("x", "x"), base) 2817 self.assertIs(s.ljust(len(s)).__class__, str) 2818 self.assertEqual(s.ljust(len(s)), base) 2819 self.assertIs(s.rjust(len(s)).__class__, str) 2820 self.assertEqual(s.rjust(len(s)), base) 2821 self.assertIs(s.center(len(s)).__class__, str) 2822 self.assertEqual(s.center(len(s)), base) 2823 self.assertIs(s.lower().__class__, str) 2824 self.assertEqual(s.lower(), base) 2825 2826 class madunicode(str): 2827 _rev = None 2828 def rev(self): 2829 if self._rev is not None: 2830 return self._rev 2831 L = list(self) 2832 L.reverse() 2833 self._rev = self.__class__("".join(L)) 2834 return self._rev 2835 u = madunicode("ABCDEF") 2836 self.assertEqual(u, "ABCDEF") 2837 self.assertEqual(u.rev(), madunicode("FEDCBA")) 2838 self.assertEqual(u.rev().rev(), madunicode("ABCDEF")) 2839 base = "12345" 2840 u = madunicode(base) 2841 self.assertEqual(str(u), base) 2842 self.assertIs(str(u).__class__, str) 2843 self.assertEqual(hash(u), hash(base)) 2844 self.assertEqual({u: 1}[base], 1) 2845 self.assertEqual({base: 1}[u], 1) 2846 self.assertIs(u.strip().__class__, str) 2847 self.assertEqual(u.strip(), base) 2848 self.assertIs(u.lstrip().__class__, str) 2849 self.assertEqual(u.lstrip(), base) 2850 self.assertIs(u.rstrip().__class__, str) 2851 self.assertEqual(u.rstrip(), base) 2852 self.assertIs(u.replace("x", "x").__class__, str) 2853 self.assertEqual(u.replace("x", "x"), base) 2854 self.assertIs(u.replace("xy", "xy").__class__, str) 2855 self.assertEqual(u.replace("xy", "xy"), base) 2856 self.assertIs(u.center(len(u)).__class__, str) 2857 self.assertEqual(u.center(len(u)), base) 2858 self.assertIs(u.ljust(len(u)).__class__, str) 2859 self.assertEqual(u.ljust(len(u)), base) 2860 self.assertIs(u.rjust(len(u)).__class__, str) 2861 self.assertEqual(u.rjust(len(u)), base) 2862 self.assertIs(u.lower().__class__, str) 2863 self.assertEqual(u.lower(), base) 2864 self.assertIs(u.upper().__class__, str) 2865 self.assertEqual(u.upper(), base) 2866 self.assertIs(u.capitalize().__class__, str) 2867 self.assertEqual(u.capitalize(), base) 2868 self.assertIs(u.title().__class__, str) 2869 self.assertEqual(u.title(), base) 2870 self.assertIs((u + "").__class__, str) 2871 self.assertEqual(u + "", base) 2872 self.assertIs(("" + u).__class__, str) 2873 self.assertEqual("" + u, base) 2874 self.assertIs((u * 0).__class__, str) 2875 self.assertEqual(u * 0, "") 2876 self.assertIs((u * 1).__class__, str) 2877 self.assertEqual(u * 1, base) 2878 self.assertIs((u * 2).__class__, str) 2879 self.assertEqual(u * 2, base + base) 2880 self.assertIs(u[:].__class__, str) 2881 self.assertEqual(u[:], base) 2882 self.assertIs(u[0:0].__class__, str) 2883 self.assertEqual(u[0:0], "") 2884 2885 class sublist(list): 2886 pass 2887 a = sublist(range(5)) 2888 self.assertEqual(a, list(range(5))) 2889 a.append("hello") 2890 self.assertEqual(a, list(range(5)) + ["hello"]) 2891 a[5] = 5 2892 self.assertEqual(a, list(range(6))) 2893 a.extend(range(6, 20)) 2894 self.assertEqual(a, list(range(20))) 2895 a[-5:] = [] 2896 self.assertEqual(a, list(range(15))) 2897 del a[10:15] 2898 self.assertEqual(len(a), 10) 2899 self.assertEqual(a, list(range(10))) 2900 self.assertEqual(list(a), list(range(10))) 2901 self.assertEqual(a[0], 0) 2902 self.assertEqual(a[9], 9) 2903 self.assertEqual(a[-10], 0) 2904 self.assertEqual(a[-1], 9) 2905 self.assertEqual(a[:5], list(range(5))) 2906 2907 ## class CountedInput(file): 2908 ## """Counts lines read by self.readline(). 2909 ## 2910 ## self.lineno is the 0-based ordinal of the last line read, up to 2911 ## a maximum of one greater than the number of lines in the file. 2912 ## 2913 ## self.ateof is true if and only if the final "" line has been read, 2914 ## at which point self.lineno stops incrementing, and further calls 2915 ## to readline() continue to return "". 2916 ## """ 2917 ## 2918 ## lineno = 0 2919 ## ateof = 0 2920 ## def readline(self): 2921 ## if self.ateof: 2922 ## return "" 2923 ## s = file.readline(self) 2924 ## # Next line works too. 2925 ## # s = super(CountedInput, self).readline() 2926 ## self.lineno += 1 2927 ## if s == "": 2928 ## self.ateof = 1 2929 ## return s 2930 ## 2931 ## f = file(name=support.TESTFN, mode='w') 2932 ## lines = ['a\n', 'b\n', 'c\n'] 2933 ## try: 2934 ## f.writelines(lines) 2935 ## f.close() 2936 ## f = CountedInput(support.TESTFN) 2937 ## for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]): 2938 ## got = f.readline() 2939 ## self.assertEqual(expected, got) 2940 ## self.assertEqual(f.lineno, i) 2941 ## self.assertEqual(f.ateof, (i > len(lines))) 2942 ## f.close() 2943 ## finally: 2944 ## try: 2945 ## f.close() 2946 ## except: 2947 ## pass 2948 ## support.unlink(support.TESTFN) 2949 2950 def test_keywords(self): 2951 # Testing keyword args to basic type constructors ... 2952 with self.assertRaisesRegex(TypeError, 'keyword argument'): 2953 int(x=1) 2954 with self.assertRaisesRegex(TypeError, 'keyword argument'): 2955 float(x=2) 2956 with self.assertRaisesRegex(TypeError, 'keyword argument'): 2957 bool(x=2) 2958 self.assertEqual(complex(imag=42, real=666), complex(666, 42)) 2959 self.assertEqual(str(object=500), '500') 2960 self.assertEqual(str(object=b'abc', errors='strict'), 'abc') 2961 with self.assertRaisesRegex(TypeError, 'keyword argument'): 2962 tuple(sequence=range(3)) 2963 with self.assertRaisesRegex(TypeError, 'keyword argument'): 2964 list(sequence=(0, 1, 2)) 2965 # note: as of Python 2.3, dict() no longer has an "items" keyword arg 2966 2967 for constructor in (int, float, int, complex, str, str, 2968 tuple, list): 2969 try: 2970 constructor(bogus_keyword_arg=1) 2971 except TypeError: 2972 pass 2973 else: 2974 self.fail("expected TypeError from bogus keyword argument to %r" 2975 % constructor) 2976 2977 def test_str_subclass_as_dict_key(self): 2978 # Testing a str subclass used as dict key .. 2979 2980 class cistr(str): 2981 """Sublcass of str that computes __eq__ case-insensitively. 2982 2983 Also computes a hash code of the string in canonical form. 2984 """ 2985 2986 def __init__(self, value): 2987 self.canonical = value.lower() 2988 self.hashcode = hash(self.canonical) 2989 2990 def __eq__(self, other): 2991 if not isinstance(other, cistr): 2992 other = cistr(other) 2993 return self.canonical == other.canonical 2994 2995 def __hash__(self): 2996 return self.hashcode 2997 2998 self.assertEqual(cistr('ABC'), 'abc') 2999 self.assertEqual('aBc', cistr('ABC')) 3000 self.assertEqual(str(cistr('ABC')), 'ABC') 3001 3002 d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3} 3003 self.assertEqual(d[cistr('one')], 1) 3004 self.assertEqual(d[cistr('tWo')], 2) 3005 self.assertEqual(d[cistr('THrEE')], 3) 3006 self.assertIn(cistr('ONe'), d) 3007 self.assertEqual(d.get(cistr('thrEE')), 3) 3008 3009 def test_classic_comparisons(self): 3010 # Testing classic comparisons... 3011 class classic: 3012 pass 3013 3014 for base in (classic, int, object): 3015 class C(base): 3016 def __init__(self, value): 3017 self.value = int(value) 3018 def __eq__(self, other): 3019 if isinstance(other, C): 3020 return self.value == other.value 3021 if isinstance(other, int) or isinstance(other, int): 3022 return self.value == other 3023 return NotImplemented 3024 def __ne__(self, other): 3025 if isinstance(other, C): 3026 return self.value != other.value 3027 if isinstance(other, int) or isinstance(other, int): 3028 return self.value != other 3029 return NotImplemented 3030 def __lt__(self, other): 3031 if isinstance(other, C): 3032 return self.value < other.value 3033 if isinstance(other, int) or isinstance(other, int): 3034 return self.value < other 3035 return NotImplemented 3036 def __le__(self, other): 3037 if isinstance(other, C): 3038 return self.value <= other.value 3039 if isinstance(other, int) or isinstance(other, int): 3040 return self.value <= other 3041 return NotImplemented 3042 def __gt__(self, other): 3043 if isinstance(other, C): 3044 return self.value > other.value 3045 if isinstance(other, int) or isinstance(other, int): 3046 return self.value > other 3047 return NotImplemented 3048 def __ge__(self, other): 3049 if isinstance(other, C): 3050 return self.value >= other.value 3051 if isinstance(other, int) or isinstance(other, int): 3052 return self.value >= other 3053 return NotImplemented 3054 3055 c1 = C(1) 3056 c2 = C(2) 3057 c3 = C(3) 3058 self.assertEqual(c1, 1) 3059 c = {1: c1, 2: c2, 3: c3} 3060 for x in 1, 2, 3: 3061 for y in 1, 2, 3: 3062 for op in "<", "<=", "==", "!=", ">", ">=": 3063 self.assertEqual(eval("c[x] %s c[y]" % op), 3064 eval("x %s y" % op), 3065 "x=%d, y=%d" % (x, y)) 3066 self.assertEqual(eval("c[x] %s y" % op), 3067 eval("x %s y" % op), 3068 "x=%d, y=%d" % (x, y)) 3069 self.assertEqual(eval("x %s c[y]" % op), 3070 eval("x %s y" % op), 3071 "x=%d, y=%d" % (x, y)) 3072 3073 def test_rich_comparisons(self): 3074 # Testing rich comparisons... 3075 class Z(complex): 3076 pass 3077 z = Z(1) 3078 self.assertEqual(z, 1+0j) 3079 self.assertEqual(1+0j, z) 3080 class ZZ(complex): 3081 def __eq__(self, other): 3082 try: 3083 return abs(self - other) <= 1e-6 3084 except: 3085 return NotImplemented 3086 zz = ZZ(1.0000003) 3087 self.assertEqual(zz, 1+0j) 3088 self.assertEqual(1+0j, zz) 3089 3090 class classic: 3091 pass 3092 for base in (classic, int, object, list): 3093 class C(base): 3094 def __init__(self, value): 3095 self.value = int(value) 3096 def __cmp__(self_, other): 3097 self.fail("shouldn't call __cmp__") 3098 def __eq__(self, other): 3099 if isinstance(other, C): 3100 return self.value == other.value 3101 if isinstance(other, int) or isinstance(other, int): 3102 return self.value == other 3103 return NotImplemented 3104 def __ne__(self, other): 3105 if isinstance(other, C): 3106 return self.value != other.value 3107 if isinstance(other, int) or isinstance(other, int): 3108 return self.value != other 3109 return NotImplemented 3110 def __lt__(self, other): 3111 if isinstance(other, C): 3112 return self.value < other.value 3113 if isinstance(other, int) or isinstance(other, int): 3114 return self.value < other 3115 return NotImplemented 3116 def __le__(self, other): 3117 if isinstance(other, C): 3118 return self.value <= other.value 3119 if isinstance(other, int) or isinstance(other, int): 3120 return self.value <= other 3121 return NotImplemented 3122 def __gt__(self, other): 3123 if isinstance(other, C): 3124 return self.value > other.value 3125 if isinstance(other, int) or isinstance(other, int): 3126 return self.value > other 3127 return NotImplemented 3128 def __ge__(self, other): 3129 if isinstance(other, C): 3130 return self.value >= other.value 3131 if isinstance(other, int) or isinstance(other, int): 3132 return self.value >= other 3133 return NotImplemented 3134 c1 = C(1) 3135 c2 = C(2) 3136 c3 = C(3) 3137 self.assertEqual(c1, 1) 3138 c = {1: c1, 2: c2, 3: c3} 3139 for x in 1, 2, 3: 3140 for y in 1, 2, 3: 3141 for op in "<", "<=", "==", "!=", ">", ">=": 3142 self.assertEqual(eval("c[x] %s c[y]" % op), 3143 eval("x %s y" % op), 3144 "x=%d, y=%d" % (x, y)) 3145 self.assertEqual(eval("c[x] %s y" % op), 3146 eval("x %s y" % op), 3147 "x=%d, y=%d" % (x, y)) 3148 self.assertEqual(eval("x %s c[y]" % op), 3149 eval("x %s y" % op), 3150 "x=%d, y=%d" % (x, y)) 3151 3152 def test_descrdoc(self): 3153 # Testing descriptor doc strings... 3154 from _io import FileIO 3155 def check(descr, what): 3156 self.assertEqual(descr.__doc__, what) 3157 check(FileIO.closed, "True if the file is closed") # getset descriptor 3158 check(complex.real, "the real part of a complex number") # member descriptor 3159 3160 def test_doc_descriptor(self): 3161 # Testing __doc__ descriptor... 3162 # SF bug 542984 3163 class DocDescr(object): 3164 def __get__(self, object, otype): 3165 if object: 3166 object = object.__class__.__name__ + ' instance' 3167 if otype: 3168 otype = otype.__name__ 3169 return 'object=%s; type=%s' % (object, otype) 3170 class OldClass: 3171 __doc__ = DocDescr() 3172 class NewClass(object): 3173 __doc__ = DocDescr() 3174 self.assertEqual(OldClass.__doc__, 'object=None; type=OldClass') 3175 self.assertEqual(OldClass().__doc__, 'object=OldClass instance; type=OldClass') 3176 self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass') 3177 self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass') 3178 3179 def test_set_class(self): 3180 # Testing __class__ assignment... 3181 class C(object): pass 3182 class D(object): pass 3183 class E(object): pass 3184 class F(D, E): pass 3185 for cls in C, D, E, F: 3186 for cls2 in C, D, E, F: 3187 x = cls() 3188 x.__class__ = cls2 3189 self.assertIs(x.__class__, cls2) 3190 x.__class__ = cls 3191 self.assertIs(x.__class__, cls) 3192 def cant(x, C): 3193 try: 3194 x.__class__ = C 3195 except TypeError: 3196 pass 3197 else: 3198 self.fail("shouldn't allow %r.__class__ = %r" % (x, C)) 3199 try: 3200 delattr(x, "__class__") 3201 except (TypeError, AttributeError): 3202 pass 3203 else: 3204 self.fail("shouldn't allow del %r.__class__" % x) 3205 cant(C(), list) 3206 cant(list(), C) 3207 cant(C(), 1) 3208 cant(C(), object) 3209 cant(object(), list) 3210 cant(list(), object) 3211 class Int(int): __slots__ = [] 3212 cant(True, int) 3213 cant(2, bool) 3214 o = object() 3215 cant(o, type(1)) 3216 cant(o, type(None)) 3217 del o 3218 class G(object): 3219 __slots__ = ["a", "b"] 3220 class H(object): 3221 __slots__ = ["b", "a"] 3222 class I(object): 3223 __slots__ = ["a", "b"] 3224 class J(object): 3225 __slots__ = ["c", "b"] 3226 class K(object): 3227 __slots__ = ["a", "b", "d"] 3228 class L(H): 3229 __slots__ = ["e"] 3230 class M(I): 3231 __slots__ = ["e"] 3232 class N(J): 3233 __slots__ = ["__weakref__"] 3234 class P(J): 3235 __slots__ = ["__dict__"] 3236 class Q(J): 3237 pass 3238 class R(J): 3239 __slots__ = ["__dict__", "__weakref__"] 3240 3241 for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)): 3242 x = cls() 3243 x.a = 1 3244 x.__class__ = cls2 3245 self.assertIs(x.__class__, cls2, 3246 "assigning %r as __class__ for %r silently failed" % (cls2, x)) 3247 self.assertEqual(x.a, 1) 3248 x.__class__ = cls 3249 self.assertIs(x.__class__, cls, 3250 "assigning %r as __class__ for %r silently failed" % (cls, x)) 3251 self.assertEqual(x.a, 1) 3252 for cls in G, J, K, L, M, N, P, R, list, Int: 3253 for cls2 in G, J, K, L, M, N, P, R, list, Int: 3254 if cls is cls2: 3255 continue 3256 cant(cls(), cls2) 3257 3258 # Issue5283: when __class__ changes in __del__, the wrong 3259 # type gets DECREF'd. 3260 class O(object): 3261 pass 3262 class A(object): 3263 def __del__(self): 3264 self.__class__ = O 3265 l = [A() for x in range(100)] 3266 del l 3267 3268 def test_set_dict(self): 3269 # Testing __dict__ assignment... 3270 class C(object): pass 3271 a = C() 3272 a.__dict__ = {'b': 1} 3273 self.assertEqual(a.b, 1) 3274 def cant(x, dict): 3275 try: 3276 x.__dict__ = dict 3277 except (AttributeError, TypeError): 3278 pass 3279 else: 3280 self.fail("shouldn't allow %r.__dict__ = %r" % (x, dict)) 3281 cant(a, None) 3282 cant(a, []) 3283 cant(a, 1) 3284 del a.__dict__ # Deleting __dict__ is allowed 3285 3286 class Base(object): 3287 pass 3288 def verify_dict_readonly(x): 3289 """ 3290 x has to be an instance of a class inheriting from Base. 3291 """ 3292 cant(x, {}) 3293 try: 3294 del x.__dict__ 3295 except (AttributeError, TypeError): 3296 pass 3297 else: 3298 self.fail("shouldn't allow del %r.__dict__" % x) 3299 dict_descr = Base.__dict__["__dict__"] 3300 try: 3301 dict_descr.__set__(x, {}) 3302 except (AttributeError, TypeError): 3303 pass 3304 else: 3305 self.fail("dict_descr allowed access to %r's dict" % x) 3306 3307 # Classes don't allow __dict__ assignment and have readonly dicts 3308 class Meta1(type, Base): 3309 pass 3310 class Meta2(Base, type): 3311 pass 3312 class D(object, metaclass=Meta1): 3313 pass 3314 class E(object, metaclass=Meta2): 3315 pass 3316 for cls in C, D, E: 3317 verify_dict_readonly(cls) 3318 class_dict = cls.__dict__ 3319 try: 3320 class_dict["spam"] = "eggs" 3321 except TypeError: 3322 pass 3323 else: 3324 self.fail("%r's __dict__ can be modified" % cls) 3325 3326 # Modules also disallow __dict__ assignment 3327 class Module1(types.ModuleType, Base): 3328 pass 3329 class Module2(Base, types.ModuleType): 3330 pass 3331 for ModuleType in Module1, Module2: 3332 mod = ModuleType("spam") 3333 verify_dict_readonly(mod) 3334 mod.__dict__["spam"] = "eggs" 3335 3336 # Exception's __dict__ can be replaced, but not deleted 3337 # (at least not any more than regular exception's __dict__ can 3338 # be deleted; on CPython it is not the case, whereas on PyPy they 3339 # can, just like any other new-style instance's __dict__.) 3340 def can_delete_dict(e): 3341 try: 3342 del e.__dict__ 3343 except (TypeError, AttributeError): 3344 return False 3345 else: 3346 return True 3347 class Exception1(Exception, Base): 3348 pass 3349 class Exception2(Base, Exception): 3350 pass 3351 for ExceptionType in Exception, Exception1, Exception2: 3352 e = ExceptionType() 3353 e.__dict__ = {"a": 1} 3354 self.assertEqual(e.a, 1) 3355 self.assertEqual(can_delete_dict(e), can_delete_dict(ValueError())) 3356 3357 def test_binary_operator_override(self): 3358 # Testing overrides of binary operations... 3359 class I(int): 3360 def __repr__(self): 3361 return "I(%r)" % int(self) 3362 def __add__(self, other): 3363 return I(int(self) + int(other)) 3364 __radd__ = __add__ 3365 def __pow__(self, other, mod=None): 3366 if mod is None: 3367 return I(pow(int(self), int(other))) 3368 else: 3369 return I(pow(int(self), int(other), int(mod))) 3370 def __rpow__(self, other, mod=None): 3371 if mod is None: 3372 return I(pow(int(other), int(self), mod)) 3373 else: 3374 return I(pow(int(other), int(self), int(mod))) 3375 3376 self.assertEqual(repr(I(1) + I(2)), "I(3)") 3377 self.assertEqual(repr(I(1) + 2), "I(3)") 3378 self.assertEqual(repr(1 + I(2)), "I(3)") 3379 self.assertEqual(repr(I(2) ** I(3)), "I(8)") 3380 self.assertEqual(repr(2 ** I(3)), "I(8)") 3381 self.assertEqual(repr(I(2) ** 3), "I(8)") 3382 self.assertEqual(repr(pow(I(2), I(3), I(5))), "I(3)") 3383 class S(str): 3384 def __eq__(self, other): 3385 return self.lower() == other.lower() 3386 3387 def test_subclass_propagation(self): 3388 # Testing propagation of slot functions to subclasses... 3389 class A(object): 3390 pass 3391 class B(A): 3392 pass 3393 class C(A): 3394 pass 3395 class D(B, C): 3396 pass 3397 d = D() 3398 orig_hash = hash(d) # related to id(d) in platform-dependent ways 3399 A.__hash__ = lambda self: 42 3400 self.assertEqual(hash(d), 42) 3401 C.__hash__ = lambda self: 314 3402 self.assertEqual(hash(d), 314) 3403 B.__hash__ = lambda self: 144 3404 self.assertEqual(hash(d), 144) 3405 D.__hash__ = lambda self: 100 3406 self.assertEqual(hash(d), 100) 3407 D.__hash__ = None 3408 self.assertRaises(TypeError, hash, d) 3409 del D.__hash__ 3410 self.assertEqual(hash(d), 144) 3411 B.__hash__ = None 3412 self.assertRaises(TypeError, hash, d) 3413 del B.__hash__ 3414 self.assertEqual(hash(d), 314) 3415 C.__hash__ = None 3416 self.assertRaises(TypeError, hash, d) 3417 del C.__hash__ 3418 self.assertEqual(hash(d), 42) 3419 A.__hash__ = None 3420 self.assertRaises(TypeError, hash, d) 3421 del A.__hash__ 3422 self.assertEqual(hash(d), orig_hash) 3423 d.foo = 42 3424 d.bar = 42 3425 self.assertEqual(d.foo, 42) 3426 self.assertEqual(d.bar, 42) 3427 def __getattribute__(self, name): 3428 if name == "foo": 3429 return 24 3430 return object.__getattribute__(self, name) 3431 A.__getattribute__ = __getattribute__ 3432 self.assertEqual(d.foo, 24) 3433 self.assertEqual(d.bar, 42) 3434 def __getattr__(self, name): 3435 if name in ("spam", "foo", "bar"): 3436 return "hello" 3437 raise AttributeError(name) 3438 B.__getattr__ = __getattr__ 3439 self.assertEqual(d.spam, "hello") 3440 self.assertEqual(d.foo, 24) 3441 self.assertEqual(d.bar, 42) 3442 del A.__getattribute__ 3443 self.assertEqual(d.foo, 42) 3444 del d.foo 3445 self.assertEqual(d.foo, "hello") 3446 self.assertEqual(d.bar, 42) 3447 del B.__getattr__ 3448 try: 3449 d.foo 3450 except AttributeError: 3451 pass 3452 else: 3453 self.fail("d.foo should be undefined now") 3454 3455 # Test a nasty bug in recurse_down_subclasses() 3456 class A(object): 3457 pass 3458 class B(A): 3459 pass 3460 del B 3461 support.gc_collect() 3462 A.__setitem__ = lambda *a: None # crash 3463 3464 def test_buffer_inheritance(self): 3465 # Testing that buffer interface is inherited ... 3466 3467 import binascii 3468 # SF bug [#470040] ParseTuple t# vs subclasses. 3469 3470 class MyBytes(bytes): 3471 pass 3472 base = b'abc' 3473 m = MyBytes(base) 3474 # b2a_hex uses the buffer interface to get its argument's value, via 3475 # PyArg_ParseTuple 't#' code. 3476 self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base)) 3477 3478 class MyInt(int): 3479 pass 3480 m = MyInt(42) 3481 try: 3482 binascii.b2a_hex(m) 3483 self.fail('subclass of int should not have a buffer interface') 3484 except TypeError: 3485 pass 3486 3487 def test_str_of_str_subclass(self): 3488 # Testing __str__ defined in subclass of str ... 3489 import binascii 3490 import io 3491 3492 class octetstring(str): 3493 def __str__(self): 3494 return binascii.b2a_hex(self.encode('ascii')).decode("ascii") 3495 def __repr__(self): 3496 return self + " repr" 3497 3498 o = octetstring('A') 3499 self.assertEqual(type(o), octetstring) 3500 self.assertEqual(type(str(o)), str) 3501 self.assertEqual(type(repr(o)), str) 3502 self.assertEqual(ord(o), 0x41) 3503 self.assertEqual(str(o), '41') 3504 self.assertEqual(repr(o), 'A repr') 3505 self.assertEqual(o.__str__(), '41') 3506 self.assertEqual(o.__repr__(), 'A repr') 3507 3508 capture = io.StringIO() 3509 # Calling str() or not exercises different internal paths. 3510 print(o, file=capture) 3511 print(str(o), file=capture) 3512 self.assertEqual(capture.getvalue(), '41\n41\n') 3513 capture.close() 3514 3515 def test_keyword_arguments(self): 3516 # Testing keyword arguments to __init__, __call__... 3517 def f(a): return a 3518 self.assertEqual(f.__call__(a=42), 42) 3519 ba = bytearray() 3520 bytearray.__init__(ba, 'abc\xbd\u20ac', 3521 encoding='latin1', errors='replace') 3522 self.assertEqual(ba, b'abc\xbd?') 3523 3524 def test_recursive_call(self): 3525 # Testing recursive __call__() by setting to instance of class... 3526 class A(object): 3527 pass 3528 3529 A.__call__ = A() 3530 try: 3531 A()() 3532 except RecursionError: 3533 pass 3534 else: 3535 self.fail("Recursion limit should have been reached for __call__()") 3536 3537 def test_delete_hook(self): 3538 # Testing __del__ hook... 3539 log = [] 3540 class C(object): 3541 def __del__(self): 3542 log.append(1) 3543 c = C() 3544 self.assertEqual(log, []) 3545 del c 3546 support.gc_collect() 3547 self.assertEqual(log, [1]) 3548 3549 class D(object): pass 3550 d = D() 3551 try: del d[0] 3552 except TypeError: pass 3553 else: self.fail("invalid del() didn't raise TypeError") 3554 3555 def test_hash_inheritance(self): 3556 # Testing hash of mutable subclasses... 3557 3558 class mydict(dict): 3559 pass 3560 d = mydict() 3561 try: 3562 hash(d) 3563 except TypeError: 3564 pass 3565 else: 3566 self.fail("hash() of dict subclass should fail") 3567 3568 class mylist(list): 3569 pass 3570 d = mylist() 3571 try: 3572 hash(d) 3573 except TypeError: 3574 pass 3575 else: 3576 self.fail("hash() of list subclass should fail") 3577 3578 def test_str_operations(self): 3579 try: 'a' + 5 3580 except TypeError: pass 3581 else: self.fail("'' + 5 doesn't raise TypeError") 3582 3583 try: ''.split('') 3584 except ValueError: pass 3585 else: self.fail("''.split('') doesn't raise ValueError") 3586 3587 try: ''.join([0]) 3588 except TypeError: pass 3589 else: self.fail("''.join([0]) doesn't raise TypeError") 3590 3591 try: ''.rindex('5') 3592 except ValueError: pass 3593 else: self.fail("''.rindex('5') doesn't raise ValueError") 3594 3595 try: '%(n)s' % None 3596 except TypeError: pass 3597 else: self.fail("'%(n)s' % None doesn't raise TypeError") 3598 3599 try: '%(n' % {} 3600 except ValueError: pass 3601 else: self.fail("'%(n' % {} '' doesn't raise ValueError") 3602 3603 try: '%*s' % ('abc') 3604 except TypeError: pass 3605 else: self.fail("'%*s' % ('abc') doesn't raise TypeError") 3606 3607 try: '%*.*s' % ('abc', 5) 3608 except TypeError: pass 3609 else: self.fail("'%*.*s' % ('abc', 5) doesn't raise TypeError") 3610 3611 try: '%s' % (1, 2) 3612 except TypeError: pass 3613 else: self.fail("'%s' % (1, 2) doesn't raise TypeError") 3614 3615 try: '%' % None 3616 except ValueError: pass 3617 else: self.fail("'%' % None doesn't raise ValueError") 3618 3619 self.assertEqual('534253'.isdigit(), 1) 3620 self.assertEqual('534253x'.isdigit(), 0) 3621 self.assertEqual('%c' % 5, '\x05') 3622 self.assertEqual('%c' % '5', '5') 3623 3624 def test_deepcopy_recursive(self): 3625 # Testing deepcopy of recursive objects... 3626 class Node: 3627 pass 3628 a = Node() 3629 b = Node() 3630 a.b = b 3631 b.a = a 3632 z = deepcopy(a) # This blew up before 3633 3634 def test_uninitialized_modules(self): 3635 # Testing uninitialized module objects... 3636 from types import ModuleType as M 3637 m = M.__new__(M) 3638 str(m) 3639 self.assertNotHasAttr(m, "__name__") 3640 self.assertNotHasAttr(m, "__file__") 3641 self.assertNotHasAttr(m, "foo") 3642 self.assertFalse(m.__dict__) # None or {} are both reasonable answers 3643 m.foo = 1 3644 self.assertEqual(m.__dict__, {"foo": 1}) 3645 3646 def test_funny_new(self): 3647 # Testing __new__ returning something unexpected... 3648 class C(object): 3649 def __new__(cls, arg): 3650 if isinstance(arg, str): return [1, 2, 3] 3651 elif isinstance(arg, int): return object.__new__(D) 3652 else: return object.__new__(cls) 3653 class D(C): 3654 def __init__(self, arg): 3655 self.foo = arg 3656 self.assertEqual(C("1"), [1, 2, 3]) 3657 self.assertEqual(D("1"), [1, 2, 3]) 3658 d = D(None) 3659 self.assertEqual(d.foo, None) 3660 d = C(1) 3661 self.assertIsInstance(d, D) 3662 self.assertEqual(d.foo, 1) 3663 d = D(1) 3664 self.assertIsInstance(d, D) 3665 self.assertEqual(d.foo, 1) 3666 3667 class C(object): 3668 @staticmethod 3669 def __new__(*args): 3670 return args 3671 self.assertEqual(C(1, 2), (C, 1, 2)) 3672 class D(C): 3673 pass 3674 self.assertEqual(D(1, 2), (D, 1, 2)) 3675 3676 class C(object): 3677 @classmethod 3678 def __new__(*args): 3679 return args 3680 self.assertEqual(C(1, 2), (C, C, 1, 2)) 3681 class D(C): 3682 pass 3683 self.assertEqual(D(1, 2), (D, D, 1, 2)) 3684 3685 def test_imul_bug(self): 3686 # Testing for __imul__ problems... 3687 # SF bug 544647 3688 class C(object): 3689 def __imul__(self, other): 3690 return (self, other) 3691 x = C() 3692 y = x 3693 y *= 1.0 3694 self.assertEqual(y, (x, 1.0)) 3695 y = x 3696 y *= 2 3697 self.assertEqual(y, (x, 2)) 3698 y = x 3699 y *= 3 3700 self.assertEqual(y, (x, 3)) 3701 y = x 3702 y *= 1<<100 3703 self.assertEqual(y, (x, 1<<100)) 3704 y = x 3705 y *= None 3706 self.assertEqual(y, (x, None)) 3707 y = x 3708 y *= "foo" 3709 self.assertEqual(y, (x, "foo")) 3710 3711 def test_copy_setstate(self): 3712 # Testing that copy.*copy() correctly uses __setstate__... 3713 import copy 3714 class C(object): 3715 def __init__(self, foo=None): 3716 self.foo = foo 3717 self.__foo = foo 3718 def setfoo(self, foo=None): 3719 self.foo = foo 3720 def getfoo(self): 3721 return self.__foo 3722 def __getstate__(self): 3723 return [self.foo] 3724 def __setstate__(self_, lst): 3725 self.assertEqual(len(lst), 1) 3726 self_.__foo = self_.foo = lst[0] 3727 a = C(42) 3728 a.setfoo(24) 3729 self.assertEqual(a.foo, 24) 3730 self.assertEqual(a.getfoo(), 42) 3731 b = copy.copy(a) 3732 self.assertEqual(b.foo, 24) 3733 self.assertEqual(b.getfoo(), 24) 3734 b = copy.deepcopy(a) 3735 self.assertEqual(b.foo, 24) 3736 self.assertEqual(b.getfoo(), 24) 3737 3738 def test_slices(self): 3739 # Testing cases with slices and overridden __getitem__ ... 3740 3741 # Strings 3742 self.assertEqual("hello"[:4], "hell") 3743 self.assertEqual("hello"[slice(4)], "hell") 3744 self.assertEqual(str.__getitem__("hello", slice(4)), "hell") 3745 class S(str): 3746 def __getitem__(self, x): 3747 return str.__getitem__(self, x) 3748 self.assertEqual(S("hello")[:4], "hell") 3749 self.assertEqual(S("hello")[slice(4)], "hell") 3750 self.assertEqual(S("hello").__getitem__(slice(4)), "hell") 3751 # Tuples 3752 self.assertEqual((1,2,3)[:2], (1,2)) 3753 self.assertEqual((1,2,3)[slice(2)], (1,2)) 3754 self.assertEqual(tuple.__getitem__((1,2,3), slice(2)), (1,2)) 3755 class T(tuple): 3756 def __getitem__(self, x): 3757 return tuple.__getitem__(self, x) 3758 self.assertEqual(T((1,2,3))[:2], (1,2)) 3759 self.assertEqual(T((1,2,3))[slice(2)], (1,2)) 3760 self.assertEqual(T((1,2,3)).__getitem__(slice(2)), (1,2)) 3761 # Lists 3762 self.assertEqual([1,2,3][:2], [1,2]) 3763 self.assertEqual([1,2,3][slice(2)], [1,2]) 3764 self.assertEqual(list.__getitem__([1,2,3], slice(2)), [1,2]) 3765 class L(list): 3766 def __getitem__(self, x): 3767 return list.__getitem__(self, x) 3768 self.assertEqual(L([1,2,3])[:2], [1,2]) 3769 self.assertEqual(L([1,2,3])[slice(2)], [1,2]) 3770 self.assertEqual(L([1,2,3]).__getitem__(slice(2)), [1,2]) 3771 # Now do lists and __setitem__ 3772 a = L([1,2,3]) 3773 a[slice(1, 3)] = [3,2] 3774 self.assertEqual(a, [1,3,2]) 3775 a[slice(0, 2, 1)] = [3,1] 3776 self.assertEqual(a, [3,1,2]) 3777 a.__setitem__(slice(1, 3), [2,1]) 3778 self.assertEqual(a, [3,2,1]) 3779 a.__setitem__(slice(0, 2, 1), [2,3]) 3780 self.assertEqual(a, [2,3,1]) 3781 3782 def test_subtype_resurrection(self): 3783 # Testing resurrection of new-style instance... 3784 3785 class C(object): 3786 container = [] 3787 3788 def __del__(self): 3789 # resurrect the instance 3790 C.container.append(self) 3791 3792 c = C() 3793 c.attr = 42 3794 3795 # The most interesting thing here is whether this blows up, due to 3796 # flawed GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1 3797 # bug). 3798 del c 3799 3800 support.gc_collect() 3801 self.assertEqual(len(C.container), 1) 3802 3803 # Make c mortal again, so that the test framework with -l doesn't report 3804 # it as a leak. 3805 del C.__del__ 3806 3807 def test_slots_trash(self): 3808 # Testing slot trash... 3809 # Deallocating deeply nested slotted trash caused stack overflows 3810 class trash(object): 3811 __slots__ = ['x'] 3812 def __init__(self, x): 3813 self.x = x 3814 o = None 3815 for i in range(50000): 3816 o = trash(o) 3817 del o 3818 3819 def test_slots_multiple_inheritance(self): 3820 # SF bug 575229, multiple inheritance w/ slots dumps core 3821 class A(object): 3822 __slots__=() 3823 class B(object): 3824 pass 3825 class C(A,B) : 3826 __slots__=() 3827 if support.check_impl_detail(): 3828 self.assertEqual(C.__basicsize__, B.__basicsize__) 3829 self.assertHasAttr(C, '__dict__') 3830 self.assertHasAttr(C, '__weakref__') 3831 C().x = 2 3832 3833 def test_rmul(self): 3834 # Testing correct invocation of __rmul__... 3835 # SF patch 592646 3836 class C(object): 3837 def __mul__(self, other): 3838 return "mul" 3839 def __rmul__(self, other): 3840 return "rmul" 3841 a = C() 3842 self.assertEqual(a*2, "mul") 3843 self.assertEqual(a*2.2, "mul") 3844 self.assertEqual(2*a, "rmul") 3845 self.assertEqual(2.2*a, "rmul") 3846 3847 def test_ipow(self): 3848 # Testing correct invocation of __ipow__... 3849 # [SF bug 620179] 3850 class C(object): 3851 def __ipow__(self, other): 3852 pass 3853 a = C() 3854 a **= 2 3855 3856 def test_mutable_bases(self): 3857 # Testing mutable bases... 3858 3859 # stuff that should work: 3860 class C(object): 3861 pass 3862 class C2(object): 3863 def __getattribute__(self, attr): 3864 if attr == 'a': 3865 return 2 3866 else: 3867 return super(C2, self).__getattribute__(attr) 3868 def meth(self): 3869 return 1 3870 class D(C): 3871 pass 3872 class E(D): 3873 pass 3874 d = D() 3875 e = E() 3876 D.__bases__ = (C,) 3877 D.__bases__ = (C2,) 3878 self.assertEqual(d.meth(), 1) 3879 self.assertEqual(e.meth(), 1) 3880 self.assertEqual(d.a, 2) 3881 self.assertEqual(e.a, 2) 3882 self.assertEqual(C2.__subclasses__(), [D]) 3883 3884 try: 3885 del D.__bases__ 3886 except (TypeError, AttributeError): 3887 pass 3888 else: 3889 self.fail("shouldn't be able to delete .__bases__") 3890 3891 try: 3892 D.__bases__ = () 3893 except TypeError as msg: 3894 if str(msg) == "a new-style class can't have only classic bases": 3895 self.fail("wrong error message for .__bases__ = ()") 3896 else: 3897 self.fail("shouldn't be able to set .__bases__ to ()") 3898 3899 try: 3900 D.__bases__ = (D,) 3901 except TypeError: 3902 pass 3903 else: 3904 # actually, we'll have crashed by here... 3905 self.fail("shouldn't be able to create inheritance cycles") 3906 3907 try: 3908 D.__bases__ = (C, C) 3909 except TypeError: 3910 pass 3911 else: 3912 self.fail("didn't detect repeated base classes") 3913 3914 try: 3915 D.__bases__ = (E,) 3916 except TypeError: 3917 pass 3918 else: 3919 self.fail("shouldn't be able to create inheritance cycles") 3920 3921 def test_builtin_bases(self): 3922 # Make sure all the builtin types can have their base queried without 3923 # segfaulting. See issue #5787. 3924 builtin_types = [tp for tp in builtins.__dict__.values() 3925 if isinstance(tp, type)] 3926 for tp in builtin_types: 3927 object.__getattribute__(tp, "__bases__") 3928 if tp is not object: 3929 self.assertEqual(len(tp.__bases__), 1, tp) 3930 3931 class L(list): 3932 pass 3933 3934 class C(object): 3935 pass 3936 3937 class D(C): 3938 pass 3939 3940 try: 3941 L.__bases__ = (dict,) 3942 except TypeError: 3943 pass 3944 else: 3945 self.fail("shouldn't turn list subclass into dict subclass") 3946 3947 try: 3948 list.__bases__ = (dict,) 3949 except TypeError: 3950 pass 3951 else: 3952 self.fail("shouldn't be able to assign to list.__bases__") 3953 3954 try: 3955 D.__bases__ = (C, list) 3956 except TypeError: 3957 pass 3958 else: 3959 assert 0, "best_base calculation found wanting" 3960 3961 def test_unsubclassable_types(self): 3962 with self.assertRaises(TypeError): 3963 class X(type(None)): 3964 pass 3965 with self.assertRaises(TypeError): 3966 class X(object, type(None)): 3967 pass 3968 with self.assertRaises(TypeError): 3969 class X(type(None), object): 3970 pass 3971 class O(object): 3972 pass 3973 with self.assertRaises(TypeError): 3974 class X(O, type(None)): 3975 pass 3976 with self.assertRaises(TypeError): 3977 class X(type(None), O): 3978 pass 3979 3980 class X(object): 3981 pass 3982 with self.assertRaises(TypeError): 3983 X.__bases__ = type(None), 3984 with self.assertRaises(TypeError): 3985 X.__bases__ = object, type(None) 3986 with self.assertRaises(TypeError): 3987 X.__bases__ = type(None), object 3988 with self.assertRaises(TypeError): 3989 X.__bases__ = O, type(None) 3990 with self.assertRaises(TypeError): 3991 X.__bases__ = type(None), O 3992 3993 def test_mutable_bases_with_failing_mro(self): 3994 # Testing mutable bases with failing mro... 3995 class WorkOnce(type): 3996 def __new__(self, name, bases, ns): 3997 self.flag = 0 3998 return super(WorkOnce, self).__new__(WorkOnce, name, bases, ns) 3999 def mro(self): 4000 if self.flag > 0: 4001 raise RuntimeError("bozo") 4002 else: 4003 self.flag += 1 4004 return type.mro(self) 4005 4006 class WorkAlways(type): 4007 def mro(self): 4008 # this is here to make sure that .mro()s aren't called 4009 # with an exception set (which was possible at one point). 4010 # An error message will be printed in a debug build. 4011 # What's a good way to test for this? 4012 return type.mro(self) 4013 4014 class C(object): 4015 pass 4016 4017 class C2(object): 4018 pass 4019 4020 class D(C): 4021 pass 4022 4023 class E(D): 4024 pass 4025 4026 class F(D, metaclass=WorkOnce): 4027 pass 4028 4029 class G(D, metaclass=WorkAlways): 4030 pass 4031 4032 # Immediate subclasses have their mro's adjusted in alphabetical 4033 # order, so E's will get adjusted before adjusting F's fails. We 4034 # check here that E's gets restored. 4035 4036 E_mro_before = E.__mro__ 4037 D_mro_before = D.__mro__ 4038 4039 try: 4040 D.__bases__ = (C2,) 4041 except RuntimeError: 4042 self.assertEqual(E.__mro__, E_mro_before) 4043 self.assertEqual(D.__mro__, D_mro_before) 4044 else: 4045 self.fail("exception not propagated") 4046 4047 def test_mutable_bases_catch_mro_conflict(self): 4048 # Testing mutable bases catch mro conflict... 4049 class A(object): 4050 pass 4051 4052 class B(object): 4053 pass 4054 4055 class C(A, B): 4056 pass 4057 4058 class D(A, B): 4059 pass 4060 4061 class E(C, D): 4062 pass 4063 4064 try: 4065 C.__bases__ = (B, A) 4066 except TypeError: 4067 pass 4068 else: 4069 self.fail("didn't catch MRO conflict") 4070 4071 def test_mutable_names(self): 4072 # Testing mutable names... 4073 class C(object): 4074 pass 4075 4076 # C.__module__ could be 'test_descr' or '__main__' 4077 mod = C.__module__ 4078 4079 C.__name__ = 'D' 4080 self.assertEqual((C.__module__, C.__name__), (mod, 'D')) 4081 4082 C.__name__ = 'D.E' 4083 self.assertEqual((C.__module__, C.__name__), (mod, 'D.E')) 4084 4085 def test_evil_type_name(self): 4086 # A badly placed Py_DECREF in type_set_name led to arbitrary code 4087 # execution while the type structure was not in a sane state, and a 4088 # possible segmentation fault as a result. See bug #16447. 4089 class Nasty(str): 4090 def __del__(self): 4091 C.__name__ = "other" 4092 4093 class C: 4094 pass 4095 4096 C.__name__ = Nasty("abc") 4097 C.__name__ = "normal" 4098 4099 def test_subclass_right_op(self): 4100 # Testing correct dispatch of subclass overloading __r<op>__... 4101 4102 # This code tests various cases where right-dispatch of a subclass 4103 # should be preferred over left-dispatch of a base class. 4104 4105 # Case 1: subclass of int; this tests code in abstract.c::binary_op1() 4106 4107 class B(int): 4108 def __floordiv__(self, other): 4109 return "B.__floordiv__" 4110 def __rfloordiv__(self, other): 4111 return "B.__rfloordiv__" 4112 4113 self.assertEqual(B(1) // 1, "B.__floordiv__") 4114 self.assertEqual(1 // B(1), "B.__rfloordiv__") 4115 4116 # Case 2: subclass of object; this is just the baseline for case 3 4117 4118 class C(object): 4119 def __floordiv__(self, other): 4120 return "C.__floordiv__" 4121 def __rfloordiv__(self, other): 4122 return "C.__rfloordiv__" 4123 4124 self.assertEqual(C() // 1, "C.__floordiv__") 4125 self.assertEqual(1 // C(), "C.__rfloordiv__") 4126 4127 # Case 3: subclass of new-style class; here it gets interesting 4128 4129 class D(C): 4130 def __floordiv__(self, other): 4131 return "D.__floordiv__" 4132 def __rfloordiv__(self, other): 4133 return "D.__rfloordiv__" 4134 4135 self.assertEqual(D() // C(), "D.__floordiv__") 4136 self.assertEqual(C() // D(), "D.__rfloordiv__") 4137 4138 # Case 4: this didn't work right in 2.2.2 and 2.3a1 4139 4140 class E(C): 4141 pass 4142 4143 self.assertEqual(E.__rfloordiv__, C.__rfloordiv__) 4144 4145 self.assertEqual(E() // 1, "C.__floordiv__") 4146 self.assertEqual(1 // E(), "C.__rfloordiv__") 4147 self.assertEqual(E() // C(), "C.__floordiv__") 4148 self.assertEqual(C() // E(), "C.__floordiv__") # This one would fail 4149 4150 @support.impl_detail("testing an internal kind of method object") 4151 def test_meth_class_get(self): 4152 # Testing __get__ method of METH_CLASS C methods... 4153 # Full coverage of descrobject.c::classmethod_get() 4154 4155 # Baseline 4156 arg = [1, 2, 3] 4157 res = {1: None, 2: None, 3: None} 4158 self.assertEqual(dict.fromkeys(arg), res) 4159 self.assertEqual({}.fromkeys(arg), res) 4160 4161 # Now get the descriptor 4162 descr = dict.__dict__["fromkeys"] 4163 4164 # More baseline using the descriptor directly 4165 self.assertEqual(descr.__get__(None, dict)(arg), res) 4166 self.assertEqual(descr.__get__({})(arg), res) 4167 4168 # Now check various error cases 4169 try: 4170 descr.__get__(None, None) 4171 except TypeError: 4172 pass 4173 else: 4174 self.fail("shouldn't have allowed descr.__get__(None, None)") 4175 try: 4176 descr.__get__(42) 4177 except TypeError: 4178 pass 4179 else: 4180 self.fail("shouldn't have allowed descr.__get__(42)") 4181 try: 4182 descr.__get__(None, 42) 4183 except TypeError: 4184 pass 4185 else: 4186 self.fail("shouldn't have allowed descr.__get__(None, 42)") 4187 try: 4188 descr.__get__(None, int) 4189 except TypeError: 4190 pass 4191 else: 4192 self.fail("shouldn't have allowed descr.__get__(None, int)") 4193 4194 def test_isinst_isclass(self): 4195 # Testing proxy isinstance() and isclass()... 4196 class Proxy(object): 4197 def __init__(self, obj): 4198 self.__obj = obj 4199 def __getattribute__(self, name): 4200 if name.startswith("_Proxy__"): 4201 return object.__getattribute__(self, name) 4202 else: 4203 return getattr(self.__obj, name) 4204 # Test with a classic class 4205 class C: 4206 pass 4207 a = C() 4208 pa = Proxy(a) 4209 self.assertIsInstance(a, C) # Baseline 4210 self.assertIsInstance(pa, C) # Test 4211 # Test with a classic subclass 4212 class D(C): 4213 pass 4214 a = D() 4215 pa = Proxy(a) 4216 self.assertIsInstance(a, C) # Baseline 4217 self.assertIsInstance(pa, C) # Test 4218 # Test with a new-style class 4219 class C(object): 4220 pass 4221 a = C() 4222 pa = Proxy(a) 4223 self.assertIsInstance(a, C) # Baseline 4224 self.assertIsInstance(pa, C) # Test 4225 # Test with a new-style subclass 4226 class D(C): 4227 pass 4228 a = D() 4229 pa = Proxy(a) 4230 self.assertIsInstance(a, C) # Baseline 4231 self.assertIsInstance(pa, C) # Test 4232 4233 def test_proxy_super(self): 4234 # Testing super() for a proxy object... 4235 class Proxy(object): 4236 def __init__(self, obj): 4237 self.__obj = obj 4238 def __getattribute__(self, name): 4239 if name.startswith("_Proxy__"): 4240 return object.__getattribute__(self, name) 4241 else: 4242 return getattr(self.__obj, name) 4243 4244 class B(object): 4245 def f(self): 4246 return "B.f" 4247 4248 class C(B): 4249 def f(self): 4250 return super(C, self).f() + "->C.f" 4251 4252 obj = C() 4253 p = Proxy(obj) 4254 self.assertEqual(C.__dict__["f"](p), "B.f->C.f") 4255 4256 def test_carloverre(self): 4257 # Testing prohibition of Carlo Verre's hack... 4258 try: 4259 object.__setattr__(str, "foo", 42) 4260 except TypeError: 4261 pass 4262 else: 4263 self.fail("Carlo Verre __setattr__ succeeded!") 4264 try: 4265 object.__delattr__(str, "lower") 4266 except TypeError: 4267 pass 4268 else: 4269 self.fail("Carlo Verre __delattr__ succeeded!") 4270 4271 def test_weakref_segfault(self): 4272 # Testing weakref segfault... 4273 # SF 742911 4274 import weakref 4275 4276 class Provoker: 4277 def __init__(self, referrent): 4278 self.ref = weakref.ref(referrent) 4279 4280 def __del__(self): 4281 x = self.ref() 4282 4283 class Oops(object): 4284 pass 4285 4286 o = Oops() 4287 o.whatever = Provoker(o) 4288 del o 4289 4290 def test_wrapper_segfault(self): 4291 # SF 927248: deeply nested wrappers could cause stack overflow 4292 f = lambda:None 4293 for i in range(1000000): 4294 f = f.__call__ 4295 f = None 4296 4297 def test_file_fault(self): 4298 # Testing sys.stdout is changed in getattr... 4299 test_stdout = sys.stdout 4300 class StdoutGuard: 4301 def __getattr__(self, attr): 4302 sys.stdout = sys.__stdout__ 4303 raise RuntimeError("Premature access to sys.stdout.%s" % attr) 4304 sys.stdout = StdoutGuard() 4305 try: 4306 print("Oops!") 4307 except RuntimeError: 4308 pass 4309 finally: 4310 sys.stdout = test_stdout 4311 4312 def test_vicious_descriptor_nonsense(self): 4313 # Testing vicious_descriptor_nonsense... 4314 4315 # A potential segfault spotted by Thomas Wouters in mail to 4316 # python-dev 2003-04-17, turned into an example & fixed by Michael 4317 # Hudson just less than four months later... 4318 4319 class Evil(object): 4320 def __hash__(self): 4321 return hash('attr') 4322 def __eq__(self, other): 4323 del C.attr 4324 return 0 4325 4326 class Descr(object): 4327 def __get__(self, ob, type=None): 4328 return 1 4329 4330 class C(object): 4331 attr = Descr() 4332 4333 c = C() 4334 c.__dict__[Evil()] = 0 4335 4336 self.assertEqual(c.attr, 1) 4337 # this makes a crash more likely: 4338 support.gc_collect() 4339 self.assertNotHasAttr(c, 'attr') 4340 4341 def test_init(self): 4342 # SF 1155938 4343 class Foo(object): 4344 def __init__(self): 4345 return 10 4346 try: 4347 Foo() 4348 except TypeError: 4349 pass 4350 else: 4351 self.fail("did not test __init__() for None return") 4352 4353 def test_method_wrapper(self): 4354 # Testing method-wrapper objects... 4355 # <type 'method-wrapper'> did not support any reflection before 2.5 4356 4357 # XXX should methods really support __eq__? 4358 4359 l = [] 4360 self.assertEqual(l.__add__, l.__add__) 4361 self.assertEqual(l.__add__, [].__add__) 4362 self.assertNotEqual(l.__add__, [5].__add__) 4363 self.assertNotEqual(l.__add__, l.__mul__) 4364 self.assertEqual(l.__add__.__name__, '__add__') 4365 if hasattr(l.__add__, '__self__'): 4366 # CPython 4367 self.assertIs(l.__add__.__self__, l) 4368 self.assertIs(l.__add__.__objclass__, list) 4369 else: 4370 # Python implementations where [].__add__ is a normal bound method 4371 self.assertIs(l.__add__.im_self, l) 4372 self.assertIs(l.__add__.im_class, list) 4373 self.assertEqual(l.__add__.__doc__, list.__add__.__doc__) 4374 try: 4375 hash(l.__add__) 4376 except TypeError: 4377 pass 4378 else: 4379 self.fail("no TypeError from hash([].__add__)") 4380 4381 t = () 4382 t += (7,) 4383 self.assertEqual(t.__add__, (7,).__add__) 4384 self.assertEqual(hash(t.__add__), hash((7,).__add__)) 4385 4386 def test_not_implemented(self): 4387 # Testing NotImplemented... 4388 # all binary methods should be able to return a NotImplemented 4389 import operator 4390 4391 def specialmethod(self, other): 4392 return NotImplemented 4393 4394 def check(expr, x, y): 4395 try: 4396 exec(expr, {'x': x, 'y': y, 'operator': operator}) 4397 except TypeError: 4398 pass 4399 else: 4400 self.fail("no TypeError from %r" % (expr,)) 4401 4402 N1 = sys.maxsize + 1 # might trigger OverflowErrors instead of 4403 # TypeErrors 4404 N2 = sys.maxsize # if sizeof(int) < sizeof(long), might trigger 4405 # ValueErrors instead of TypeErrors 4406 for name, expr, iexpr in [ 4407 ('__add__', 'x + y', 'x += y'), 4408 ('__sub__', 'x - y', 'x -= y'), 4409 ('__mul__', 'x * y', 'x *= y'), 4410 ('__matmul__', 'x @ y', 'x @= y'), 4411 ('__truediv__', 'x / y', 'x /= y'), 4412 ('__floordiv__', 'x // y', 'x //= y'), 4413 ('__mod__', 'x % y', 'x %= y'), 4414 ('__divmod__', 'divmod(x, y)', None), 4415 ('__pow__', 'x ** y', 'x **= y'), 4416 ('__lshift__', 'x << y', 'x <<= y'), 4417 ('__rshift__', 'x >> y', 'x >>= y'), 4418 ('__and__', 'x & y', 'x &= y'), 4419 ('__or__', 'x | y', 'x |= y'), 4420 ('__xor__', 'x ^ y', 'x ^= y')]: 4421 rname = '__r' + name[2:] 4422 A = type('A', (), {name: specialmethod}) 4423 a = A() 4424 check(expr, a, a) 4425 check(expr, a, N1) 4426 check(expr, a, N2) 4427 if iexpr: 4428 check(iexpr, a, a) 4429 check(iexpr, a, N1) 4430 check(iexpr, a, N2) 4431 iname = '__i' + name[2:] 4432 C = type('C', (), {iname: specialmethod}) 4433 c = C() 4434 check(iexpr, c, a) 4435 check(iexpr, c, N1) 4436 check(iexpr, c, N2) 4437 4438 def test_assign_slice(self): 4439 # ceval.c's assign_slice used to check for 4440 # tp->tp_as_sequence->sq_slice instead of 4441 # tp->tp_as_sequence->sq_ass_slice 4442 4443 class C(object): 4444 def __setitem__(self, idx, value): 4445 self.value = value 4446 4447 c = C() 4448 c[1:2] = 3 4449 self.assertEqual(c.value, 3) 4450 4451 def test_set_and_no_get(self): 4452 # See 4453 # http://mail.python.org/pipermail/python-dev/2010-January/095637.html 4454 class Descr(object): 4455 4456 def __init__(self, name): 4457 self.name = name 4458 4459 def __set__(self, obj, value): 4460 obj.__dict__[self.name] = value 4461 descr = Descr("a") 4462 4463 class X(object): 4464 a = descr 4465 4466 x = X() 4467 self.assertIs(x.a, descr) 4468 x.a = 42 4469 self.assertEqual(x.a, 42) 4470 4471 # Also check type_getattro for correctness. 4472 class Meta(type): 4473 pass 4474 class X(metaclass=Meta): 4475 pass 4476 X.a = 42 4477 Meta.a = Descr("a") 4478 self.assertEqual(X.a, 42) 4479 4480 def test_getattr_hooks(self): 4481 # issue 4230 4482 4483 class Descriptor(object): 4484 counter = 0 4485 def __get__(self, obj, objtype=None): 4486 def getter(name): 4487 self.counter += 1 4488 raise AttributeError(name) 4489 return getter 4490 4491 descr = Descriptor() 4492 class A(object): 4493 __getattribute__ = descr 4494 class B(object): 4495 __getattr__ = descr 4496 class C(object): 4497 __getattribute__ = descr 4498 __getattr__ = descr 4499 4500 self.assertRaises(AttributeError, getattr, A(), "attr") 4501 self.assertEqual(descr.counter, 1) 4502 self.assertRaises(AttributeError, getattr, B(), "attr") 4503 self.assertEqual(descr.counter, 2) 4504 self.assertRaises(AttributeError, getattr, C(), "attr") 4505 self.assertEqual(descr.counter, 4) 4506 4507 class EvilGetattribute(object): 4508 # This used to segfault 4509 def __getattr__(self, name): 4510 raise AttributeError(name) 4511 def __getattribute__(self, name): 4512 del EvilGetattribute.__getattr__ 4513 for i in range(5): 4514 gc.collect() 4515 raise AttributeError(name) 4516 4517 self.assertRaises(AttributeError, getattr, EvilGetattribute(), "attr") 4518 4519 def test_type___getattribute__(self): 4520 self.assertRaises(TypeError, type.__getattribute__, list, type) 4521 4522 def test_abstractmethods(self): 4523 # type pretends not to have __abstractmethods__. 4524 self.assertRaises(AttributeError, getattr, type, "__abstractmethods__") 4525 class meta(type): 4526 pass 4527 self.assertRaises(AttributeError, getattr, meta, "__abstractmethods__") 4528 class X(object): 4529 pass 4530 with self.assertRaises(AttributeError): 4531 del X.__abstractmethods__ 4532 4533 def test_proxy_call(self): 4534 class FakeStr: 4535 __class__ = str 4536 4537 fake_str = FakeStr() 4538 # isinstance() reads __class__ 4539 self.assertIsInstance(fake_str, str) 4540 4541 # call a method descriptor 4542 with self.assertRaises(TypeError): 4543 str.split(fake_str) 4544 4545 # call a slot wrapper descriptor 4546 with self.assertRaises(TypeError): 4547 str.__add__(fake_str, "abc") 4548 4549 def test_repr_as_str(self): 4550 # Issue #11603: crash or infinite loop when rebinding __str__ as 4551 # __repr__. 4552 class Foo: 4553 pass 4554 Foo.__repr__ = Foo.__str__ 4555 foo = Foo() 4556 self.assertRaises(RecursionError, str, foo) 4557 self.assertRaises(RecursionError, repr, foo) 4558 4559 def test_mixing_slot_wrappers(self): 4560 class X(dict): 4561 __setattr__ = dict.__setitem__ 4562 x = X() 4563 x.y = 42 4564 self.assertEqual(x["y"], 42) 4565 4566 def test_slot_shadows_class_variable(self): 4567 with self.assertRaises(ValueError) as cm: 4568 class X: 4569 __slots__ = ["foo"] 4570 foo = None 4571 m = str(cm.exception) 4572 self.assertEqual("'foo' in __slots__ conflicts with class variable", m) 4573 4574 def test_set_doc(self): 4575 class X: 4576 "elephant" 4577 X.__doc__ = "banana" 4578 self.assertEqual(X.__doc__, "banana") 4579 with self.assertRaises(TypeError) as cm: 4580 type(list).__dict__["__doc__"].__set__(list, "blah") 4581 self.assertIn("can't set list.__doc__", str(cm.exception)) 4582 with self.assertRaises(TypeError) as cm: 4583 type(X).__dict__["__doc__"].__delete__(X) 4584 self.assertIn("can't delete X.__doc__", str(cm.exception)) 4585 self.assertEqual(X.__doc__, "banana") 4586 4587 def test_qualname(self): 4588 descriptors = [str.lower, complex.real, float.real, int.__add__] 4589 types = ['method', 'member', 'getset', 'wrapper'] 4590 4591 # make sure we have an example of each type of descriptor 4592 for d, n in zip(descriptors, types): 4593 self.assertEqual(type(d).__name__, n + '_descriptor') 4594 4595 for d in descriptors: 4596 qualname = d.__objclass__.__qualname__ + '.' + d.__name__ 4597 self.assertEqual(d.__qualname__, qualname) 4598 4599 self.assertEqual(str.lower.__qualname__, 'str.lower') 4600 self.assertEqual(complex.real.__qualname__, 'complex.real') 4601 self.assertEqual(float.real.__qualname__, 'float.real') 4602 self.assertEqual(int.__add__.__qualname__, 'int.__add__') 4603 4604 class X: 4605 pass 4606 with self.assertRaises(TypeError): 4607 del X.__qualname__ 4608 4609 self.assertRaises(TypeError, type.__dict__['__qualname__'].__set__, 4610 str, 'Oink') 4611 4612 global Y 4613 class Y: 4614 class Inside: 4615 pass 4616 self.assertEqual(Y.__qualname__, 'Y') 4617 self.assertEqual(Y.Inside.__qualname__, 'Y.Inside') 4618 4619 def test_qualname_dict(self): 4620 ns = {'__qualname__': 'some.name'} 4621 tp = type('Foo', (), ns) 4622 self.assertEqual(tp.__qualname__, 'some.name') 4623 self.assertNotIn('__qualname__', tp.__dict__) 4624 self.assertEqual(ns, {'__qualname__': 'some.name'}) 4625 4626 ns = {'__qualname__': 1} 4627 self.assertRaises(TypeError, type, 'Foo', (), ns) 4628 4629 def test_cycle_through_dict(self): 4630 # See bug #1469629 4631 class X(dict): 4632 def __init__(self): 4633 dict.__init__(self) 4634 self.__dict__ = self 4635 x = X() 4636 x.attr = 42 4637 wr = weakref.ref(x) 4638 del x 4639 support.gc_collect() 4640 self.assertIsNone(wr()) 4641 for o in gc.get_objects(): 4642 self.assertIsNot(type(o), X) 4643 4644 def test_object_new_and_init_with_parameters(self): 4645 # See issue #1683368 4646 class OverrideNeither: 4647 pass 4648 self.assertRaises(TypeError, OverrideNeither, 1) 4649 self.assertRaises(TypeError, OverrideNeither, kw=1) 4650 class OverrideNew: 4651 def __new__(cls, foo, kw=0, *args, **kwds): 4652 return object.__new__(cls, *args, **kwds) 4653 class OverrideInit: 4654 def __init__(self, foo, kw=0, *args, **kwargs): 4655 return object.__init__(self, *args, **kwargs) 4656 class OverrideBoth(OverrideNew, OverrideInit): 4657 pass 4658 for case in OverrideNew, OverrideInit, OverrideBoth: 4659 case(1) 4660 case(1, kw=2) 4661 self.assertRaises(TypeError, case, 1, 2, 3) 4662 self.assertRaises(TypeError, case, 1, 2, foo=3) 4663 4664 def test_subclassing_does_not_duplicate_dict_descriptors(self): 4665 class Base: 4666 pass 4667 class Sub(Base): 4668 pass 4669 self.assertIn("__dict__", Base.__dict__) 4670 self.assertNotIn("__dict__", Sub.__dict__) 4671 4672 def test_bound_method_repr(self): 4673 class Foo: 4674 def method(self): 4675 pass 4676 self.assertRegex(repr(Foo().method), 4677 r"<bound method .*Foo\.method of <.*Foo object at .*>>") 4678 4679 4680 class Base: 4681 def method(self): 4682 pass 4683 class Derived1(Base): 4684 pass 4685 class Derived2(Base): 4686 def method(self): 4687 pass 4688 base = Base() 4689 derived1 = Derived1() 4690 derived2 = Derived2() 4691 super_d2 = super(Derived2, derived2) 4692 self.assertRegex(repr(base.method), 4693 r"<bound method .*Base\.method of <.*Base object at .*>>") 4694 self.assertRegex(repr(derived1.method), 4695 r"<bound method .*Base\.method of <.*Derived1 object at .*>>") 4696 self.assertRegex(repr(derived2.method), 4697 r"<bound method .*Derived2\.method of <.*Derived2 object at .*>>") 4698 self.assertRegex(repr(super_d2.method), 4699 r"<bound method .*Base\.method of <.*Derived2 object at .*>>") 4700 4701 class Foo: 4702 @classmethod 4703 def method(cls): 4704 pass 4705 foo = Foo() 4706 self.assertRegex(repr(foo.method), # access via instance 4707 r"<bound method .*Foo\.method of <class '.*Foo'>>") 4708 self.assertRegex(repr(Foo.method), # access via the class 4709 r"<bound method .*Foo\.method of <class '.*Foo'>>") 4710 4711 4712 class MyCallable: 4713 def __call__(self, arg): 4714 pass 4715 func = MyCallable() # func has no __name__ or __qualname__ attributes 4716 instance = object() 4717 method = types.MethodType(func, instance) 4718 self.assertRegex(repr(method), 4719 r"<bound method \? of <object object at .*>>") 4720 func.__name__ = "name" 4721 self.assertRegex(repr(method), 4722 r"<bound method name of <object object at .*>>") 4723 func.__qualname__ = "qualname" 4724 self.assertRegex(repr(method), 4725 r"<bound method qualname of <object object at .*>>") 4726 4727 4728class DictProxyTests(unittest.TestCase): 4729 def setUp(self): 4730 class C(object): 4731 def meth(self): 4732 pass 4733 self.C = C 4734 4735 @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 4736 'trace function introduces __local__') 4737 def test_iter_keys(self): 4738 # Testing dict-proxy keys... 4739 it = self.C.__dict__.keys() 4740 self.assertNotIsInstance(it, list) 4741 keys = list(it) 4742 keys.sort() 4743 self.assertEqual(keys, ['__dict__', '__doc__', '__module__', 4744 '__weakref__', 'meth']) 4745 4746 @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 4747 'trace function introduces __local__') 4748 def test_iter_values(self): 4749 # Testing dict-proxy values... 4750 it = self.C.__dict__.values() 4751 self.assertNotIsInstance(it, list) 4752 values = list(it) 4753 self.assertEqual(len(values), 5) 4754 4755 @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 4756 'trace function introduces __local__') 4757 def test_iter_items(self): 4758 # Testing dict-proxy iteritems... 4759 it = self.C.__dict__.items() 4760 self.assertNotIsInstance(it, list) 4761 keys = [item[0] for item in it] 4762 keys.sort() 4763 self.assertEqual(keys, ['__dict__', '__doc__', '__module__', 4764 '__weakref__', 'meth']) 4765 4766 def test_dict_type_with_metaclass(self): 4767 # Testing type of __dict__ when metaclass set... 4768 class B(object): 4769 pass 4770 class M(type): 4771 pass 4772 class C(metaclass=M): 4773 # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy 4774 pass 4775 self.assertEqual(type(C.__dict__), type(B.__dict__)) 4776 4777 def test_repr(self): 4778 # Testing mappingproxy.__repr__. 4779 # We can't blindly compare with the repr of another dict as ordering 4780 # of keys and values is arbitrary and may differ. 4781 r = repr(self.C.__dict__) 4782 self.assertTrue(r.startswith('mappingproxy('), r) 4783 self.assertTrue(r.endswith(')'), r) 4784 for k, v in self.C.__dict__.items(): 4785 self.assertIn('{!r}: {!r}'.format(k, v), r) 4786 4787 4788class PTypesLongInitTest(unittest.TestCase): 4789 # This is in its own TestCase so that it can be run before any other tests. 4790 def test_pytype_long_ready(self): 4791 # Testing SF bug 551412 ... 4792 4793 # This dumps core when SF bug 551412 isn't fixed -- 4794 # but only when test_descr.py is run separately. 4795 # (That can't be helped -- as soon as PyType_Ready() 4796 # is called for PyLong_Type, the bug is gone.) 4797 class UserLong(object): 4798 def __pow__(self, *args): 4799 pass 4800 try: 4801 pow(0, UserLong(), 0) 4802 except: 4803 pass 4804 4805 # Another segfault only when run early 4806 # (before PyType_Ready(tuple) is called) 4807 type.mro(tuple) 4808 4809 4810class MiscTests(unittest.TestCase): 4811 def test_type_lookup_mro_reference(self): 4812 # Issue #14199: _PyType_Lookup() has to keep a strong reference to 4813 # the type MRO because it may be modified during the lookup, if 4814 # __bases__ is set during the lookup for example. 4815 class MyKey(object): 4816 def __hash__(self): 4817 return hash('mykey') 4818 4819 def __eq__(self, other): 4820 X.__bases__ = (Base2,) 4821 4822 class Base(object): 4823 mykey = 'from Base' 4824 mykey2 = 'from Base' 4825 4826 class Base2(object): 4827 mykey = 'from Base2' 4828 mykey2 = 'from Base2' 4829 4830 X = type('X', (Base,), {MyKey(): 5}) 4831 # mykey is read from Base 4832 self.assertEqual(X.mykey, 'from Base') 4833 # mykey2 is read from Base2 because MyKey.__eq__ has set __bases__ 4834 self.assertEqual(X.mykey2, 'from Base2') 4835 4836 4837class PicklingTests(unittest.TestCase): 4838 4839 def _check_reduce(self, proto, obj, args=(), kwargs={}, state=None, 4840 listitems=None, dictitems=None): 4841 if proto >= 2: 4842 reduce_value = obj.__reduce_ex__(proto) 4843 if kwargs: 4844 self.assertEqual(reduce_value[0], copyreg.__newobj_ex__) 4845 self.assertEqual(reduce_value[1], (type(obj), args, kwargs)) 4846 else: 4847 self.assertEqual(reduce_value[0], copyreg.__newobj__) 4848 self.assertEqual(reduce_value[1], (type(obj),) + args) 4849 self.assertEqual(reduce_value[2], state) 4850 if listitems is not None: 4851 self.assertListEqual(list(reduce_value[3]), listitems) 4852 else: 4853 self.assertIsNone(reduce_value[3]) 4854 if dictitems is not None: 4855 self.assertDictEqual(dict(reduce_value[4]), dictitems) 4856 else: 4857 self.assertIsNone(reduce_value[4]) 4858 else: 4859 base_type = type(obj).__base__ 4860 reduce_value = (copyreg._reconstructor, 4861 (type(obj), 4862 base_type, 4863 None if base_type is object else base_type(obj))) 4864 if state is not None: 4865 reduce_value += (state,) 4866 self.assertEqual(obj.__reduce_ex__(proto), reduce_value) 4867 self.assertEqual(obj.__reduce__(), reduce_value) 4868 4869 def test_reduce(self): 4870 protocols = range(pickle.HIGHEST_PROTOCOL + 1) 4871 args = (-101, "spam") 4872 kwargs = {'bacon': -201, 'fish': -301} 4873 state = {'cheese': -401} 4874 4875 class C1: 4876 def __getnewargs__(self): 4877 return args 4878 obj = C1() 4879 for proto in protocols: 4880 self._check_reduce(proto, obj, args) 4881 4882 for name, value in state.items(): 4883 setattr(obj, name, value) 4884 for proto in protocols: 4885 self._check_reduce(proto, obj, args, state=state) 4886 4887 class C2: 4888 def __getnewargs__(self): 4889 return "bad args" 4890 obj = C2() 4891 for proto in protocols: 4892 if proto >= 2: 4893 with self.assertRaises(TypeError): 4894 obj.__reduce_ex__(proto) 4895 4896 class C3: 4897 def __getnewargs_ex__(self): 4898 return (args, kwargs) 4899 obj = C3() 4900 for proto in protocols: 4901 if proto >= 2: 4902 self._check_reduce(proto, obj, args, kwargs) 4903 4904 class C4: 4905 def __getnewargs_ex__(self): 4906 return (args, "bad dict") 4907 class C5: 4908 def __getnewargs_ex__(self): 4909 return ("bad tuple", kwargs) 4910 class C6: 4911 def __getnewargs_ex__(self): 4912 return () 4913 class C7: 4914 def __getnewargs_ex__(self): 4915 return "bad args" 4916 for proto in protocols: 4917 for cls in C4, C5, C6, C7: 4918 obj = cls() 4919 if proto >= 2: 4920 with self.assertRaises((TypeError, ValueError)): 4921 obj.__reduce_ex__(proto) 4922 4923 class C9: 4924 def __getnewargs_ex__(self): 4925 return (args, {}) 4926 obj = C9() 4927 for proto in protocols: 4928 self._check_reduce(proto, obj, args) 4929 4930 class C10: 4931 def __getnewargs_ex__(self): 4932 raise IndexError 4933 obj = C10() 4934 for proto in protocols: 4935 if proto >= 2: 4936 with self.assertRaises(IndexError): 4937 obj.__reduce_ex__(proto) 4938 4939 class C11: 4940 def __getstate__(self): 4941 return state 4942 obj = C11() 4943 for proto in protocols: 4944 self._check_reduce(proto, obj, state=state) 4945 4946 class C12: 4947 def __getstate__(self): 4948 return "not dict" 4949 obj = C12() 4950 for proto in protocols: 4951 self._check_reduce(proto, obj, state="not dict") 4952 4953 class C13: 4954 def __getstate__(self): 4955 raise IndexError 4956 obj = C13() 4957 for proto in protocols: 4958 with self.assertRaises(IndexError): 4959 obj.__reduce_ex__(proto) 4960 if proto < 2: 4961 with self.assertRaises(IndexError): 4962 obj.__reduce__() 4963 4964 class C14: 4965 __slots__ = tuple(state) 4966 def __init__(self): 4967 for name, value in state.items(): 4968 setattr(self, name, value) 4969 4970 obj = C14() 4971 for proto in protocols: 4972 if proto >= 2: 4973 self._check_reduce(proto, obj, state=(None, state)) 4974 else: 4975 with self.assertRaises(TypeError): 4976 obj.__reduce_ex__(proto) 4977 with self.assertRaises(TypeError): 4978 obj.__reduce__() 4979 4980 class C15(dict): 4981 pass 4982 obj = C15({"quebec": -601}) 4983 for proto in protocols: 4984 self._check_reduce(proto, obj, dictitems=dict(obj)) 4985 4986 class C16(list): 4987 pass 4988 obj = C16(["yukon"]) 4989 for proto in protocols: 4990 self._check_reduce(proto, obj, listitems=list(obj)) 4991 4992 def test_special_method_lookup(self): 4993 protocols = range(pickle.HIGHEST_PROTOCOL + 1) 4994 class Picky: 4995 def __getstate__(self): 4996 return {} 4997 4998 def __getattr__(self, attr): 4999 if attr in ("__getnewargs__", "__getnewargs_ex__"): 5000 raise AssertionError(attr) 5001 return None 5002 for protocol in protocols: 5003 state = {} if protocol >= 2 else None 5004 self._check_reduce(protocol, Picky(), state=state) 5005 5006 def _assert_is_copy(self, obj, objcopy, msg=None): 5007 """Utility method to verify if two objects are copies of each others. 5008 """ 5009 if msg is None: 5010 msg = "{!r} is not a copy of {!r}".format(obj, objcopy) 5011 if type(obj).__repr__ is object.__repr__: 5012 # We have this limitation for now because we use the object's repr 5013 # to help us verify that the two objects are copies. This allows 5014 # us to delegate the non-generic verification logic to the objects 5015 # themselves. 5016 raise ValueError("object passed to _assert_is_copy must " + 5017 "override the __repr__ method.") 5018 self.assertIsNot(obj, objcopy, msg=msg) 5019 self.assertIs(type(obj), type(objcopy), msg=msg) 5020 if hasattr(obj, '__dict__'): 5021 self.assertDictEqual(obj.__dict__, objcopy.__dict__, msg=msg) 5022 self.assertIsNot(obj.__dict__, objcopy.__dict__, msg=msg) 5023 if hasattr(obj, '__slots__'): 5024 self.assertListEqual(obj.__slots__, objcopy.__slots__, msg=msg) 5025 for slot in obj.__slots__: 5026 self.assertEqual( 5027 hasattr(obj, slot), hasattr(objcopy, slot), msg=msg) 5028 self.assertEqual(getattr(obj, slot, None), 5029 getattr(objcopy, slot, None), msg=msg) 5030 self.assertEqual(repr(obj), repr(objcopy), msg=msg) 5031 5032 @staticmethod 5033 def _generate_pickle_copiers(): 5034 """Utility method to generate the many possible pickle configurations. 5035 """ 5036 class PickleCopier: 5037 "This class copies object using pickle." 5038 def __init__(self, proto, dumps, loads): 5039 self.proto = proto 5040 self.dumps = dumps 5041 self.loads = loads 5042 def copy(self, obj): 5043 return self.loads(self.dumps(obj, self.proto)) 5044 def __repr__(self): 5045 # We try to be as descriptive as possible here since this is 5046 # the string which we will allow us to tell the pickle 5047 # configuration we are using during debugging. 5048 return ("PickleCopier(proto={}, dumps={}.{}, loads={}.{})" 5049 .format(self.proto, 5050 self.dumps.__module__, self.dumps.__qualname__, 5051 self.loads.__module__, self.loads.__qualname__)) 5052 return (PickleCopier(*args) for args in 5053 itertools.product(range(pickle.HIGHEST_PROTOCOL + 1), 5054 {pickle.dumps, pickle._dumps}, 5055 {pickle.loads, pickle._loads})) 5056 5057 def test_pickle_slots(self): 5058 # Tests pickling of classes with __slots__. 5059 5060 # Pickling of classes with __slots__ but without __getstate__ should 5061 # fail (if using protocol 0 or 1) 5062 global C 5063 class C: 5064 __slots__ = ['a'] 5065 with self.assertRaises(TypeError): 5066 pickle.dumps(C(), 0) 5067 5068 global D 5069 class D(C): 5070 pass 5071 with self.assertRaises(TypeError): 5072 pickle.dumps(D(), 0) 5073 5074 class C: 5075 "A class with __getstate__ and __setstate__ implemented." 5076 __slots__ = ['a'] 5077 def __getstate__(self): 5078 state = getattr(self, '__dict__', {}).copy() 5079 for cls in type(self).__mro__: 5080 for slot in cls.__dict__.get('__slots__', ()): 5081 try: 5082 state[slot] = getattr(self, slot) 5083 except AttributeError: 5084 pass 5085 return state 5086 def __setstate__(self, state): 5087 for k, v in state.items(): 5088 setattr(self, k, v) 5089 def __repr__(self): 5090 return "%s()<%r>" % (type(self).__name__, self.__getstate__()) 5091 5092 class D(C): 5093 "A subclass of a class with slots." 5094 pass 5095 5096 global E 5097 class E(C): 5098 "A subclass with an extra slot." 5099 __slots__ = ['b'] 5100 5101 # Now it should work 5102 for pickle_copier in self._generate_pickle_copiers(): 5103 with self.subTest(pickle_copier=pickle_copier): 5104 x = C() 5105 y = pickle_copier.copy(x) 5106 self._assert_is_copy(x, y) 5107 5108 x.a = 42 5109 y = pickle_copier.copy(x) 5110 self._assert_is_copy(x, y) 5111 5112 x = D() 5113 x.a = 42 5114 x.b = 100 5115 y = pickle_copier.copy(x) 5116 self._assert_is_copy(x, y) 5117 5118 x = E() 5119 x.a = 42 5120 x.b = "foo" 5121 y = pickle_copier.copy(x) 5122 self._assert_is_copy(x, y) 5123 5124 def test_reduce_copying(self): 5125 # Tests pickling and copying new-style classes and objects. 5126 global C1 5127 class C1: 5128 "The state of this class is copyable via its instance dict." 5129 ARGS = (1, 2) 5130 NEED_DICT_COPYING = True 5131 def __init__(self, a, b): 5132 super().__init__() 5133 self.a = a 5134 self.b = b 5135 def __repr__(self): 5136 return "C1(%r, %r)" % (self.a, self.b) 5137 5138 global C2 5139 class C2(list): 5140 "A list subclass copyable via __getnewargs__." 5141 ARGS = (1, 2) 5142 NEED_DICT_COPYING = False 5143 def __new__(cls, a, b): 5144 self = super().__new__(cls) 5145 self.a = a 5146 self.b = b 5147 return self 5148 def __init__(self, *args): 5149 super().__init__() 5150 # This helps testing that __init__ is not called during the 5151 # unpickling process, which would cause extra appends. 5152 self.append("cheese") 5153 @classmethod 5154 def __getnewargs__(cls): 5155 return cls.ARGS 5156 def __repr__(self): 5157 return "C2(%r, %r)<%r>" % (self.a, self.b, list(self)) 5158 5159 global C3 5160 class C3(list): 5161 "A list subclass copyable via __getstate__." 5162 ARGS = (1, 2) 5163 NEED_DICT_COPYING = False 5164 def __init__(self, a, b): 5165 self.a = a 5166 self.b = b 5167 # This helps testing that __init__ is not called during the 5168 # unpickling process, which would cause extra appends. 5169 self.append("cheese") 5170 @classmethod 5171 def __getstate__(cls): 5172 return cls.ARGS 5173 def __setstate__(self, state): 5174 a, b = state 5175 self.a = a 5176 self.b = b 5177 def __repr__(self): 5178 return "C3(%r, %r)<%r>" % (self.a, self.b, list(self)) 5179 5180 global C4 5181 class C4(int): 5182 "An int subclass copyable via __getnewargs__." 5183 ARGS = ("hello", "world", 1) 5184 NEED_DICT_COPYING = False 5185 def __new__(cls, a, b, value): 5186 self = super().__new__(cls, value) 5187 self.a = a 5188 self.b = b 5189 return self 5190 @classmethod 5191 def __getnewargs__(cls): 5192 return cls.ARGS 5193 def __repr__(self): 5194 return "C4(%r, %r)<%r>" % (self.a, self.b, int(self)) 5195 5196 global C5 5197 class C5(int): 5198 "An int subclass copyable via __getnewargs_ex__." 5199 ARGS = (1, 2) 5200 KWARGS = {'value': 3} 5201 NEED_DICT_COPYING = False 5202 def __new__(cls, a, b, *, value=0): 5203 self = super().__new__(cls, value) 5204 self.a = a 5205 self.b = b 5206 return self 5207 @classmethod 5208 def __getnewargs_ex__(cls): 5209 return (cls.ARGS, cls.KWARGS) 5210 def __repr__(self): 5211 return "C5(%r, %r)<%r>" % (self.a, self.b, int(self)) 5212 5213 test_classes = (C1, C2, C3, C4, C5) 5214 # Testing copying through pickle 5215 pickle_copiers = self._generate_pickle_copiers() 5216 for cls, pickle_copier in itertools.product(test_classes, pickle_copiers): 5217 with self.subTest(cls=cls, pickle_copier=pickle_copier): 5218 kwargs = getattr(cls, 'KWARGS', {}) 5219 obj = cls(*cls.ARGS, **kwargs) 5220 proto = pickle_copier.proto 5221 objcopy = pickle_copier.copy(obj) 5222 self._assert_is_copy(obj, objcopy) 5223 # For test classes that supports this, make sure we didn't go 5224 # around the reduce protocol by simply copying the attribute 5225 # dictionary. We clear attributes using the previous copy to 5226 # not mutate the original argument. 5227 if proto >= 2 and not cls.NEED_DICT_COPYING: 5228 objcopy.__dict__.clear() 5229 objcopy2 = pickle_copier.copy(objcopy) 5230 self._assert_is_copy(obj, objcopy2) 5231 5232 # Testing copying through copy.deepcopy() 5233 for cls in test_classes: 5234 with self.subTest(cls=cls): 5235 kwargs = getattr(cls, 'KWARGS', {}) 5236 obj = cls(*cls.ARGS, **kwargs) 5237 objcopy = deepcopy(obj) 5238 self._assert_is_copy(obj, objcopy) 5239 # For test classes that supports this, make sure we didn't go 5240 # around the reduce protocol by simply copying the attribute 5241 # dictionary. We clear attributes using the previous copy to 5242 # not mutate the original argument. 5243 if not cls.NEED_DICT_COPYING: 5244 objcopy.__dict__.clear() 5245 objcopy2 = deepcopy(objcopy) 5246 self._assert_is_copy(obj, objcopy2) 5247 5248 def test_issue24097(self): 5249 # Slot name is freed inside __getattr__ and is later used. 5250 class S(str): # Not interned 5251 pass 5252 class A: 5253 __slotnames__ = [S('spam')] 5254 def __getattr__(self, attr): 5255 if attr == 'spam': 5256 A.__slotnames__[:] = [S('spam')] 5257 return 42 5258 else: 5259 raise AttributeError 5260 5261 import copyreg 5262 expected = (copyreg.__newobj__, (A,), (None, {'spam': 42}), None, None) 5263 self.assertEqual(A().__reduce_ex__(2), expected) # Shouldn't crash 5264 5265 def test_object_reduce(self): 5266 # Issue #29914 5267 # __reduce__() takes no arguments 5268 object().__reduce__() 5269 with self.assertRaises(TypeError): 5270 object().__reduce__(0) 5271 # __reduce_ex__() takes one integer argument 5272 object().__reduce_ex__(0) 5273 with self.assertRaises(TypeError): 5274 object().__reduce_ex__() 5275 with self.assertRaises(TypeError): 5276 object().__reduce_ex__(None) 5277 5278 5279class SharedKeyTests(unittest.TestCase): 5280 5281 @support.cpython_only 5282 def test_subclasses(self): 5283 # Verify that subclasses can share keys (per PEP 412) 5284 class A: 5285 pass 5286 class B(A): 5287 pass 5288 5289 a, b = A(), B() 5290 self.assertEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(b))) 5291 self.assertLess(sys.getsizeof(vars(a)), sys.getsizeof({})) 5292 # Initial hash table can contain at most 5 elements. 5293 # Set 6 attributes to cause internal resizing. 5294 a.x, a.y, a.z, a.w, a.v, a.u = range(6) 5295 self.assertNotEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(b))) 5296 a2 = A() 5297 self.assertEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(a2))) 5298 self.assertLess(sys.getsizeof(vars(a)), sys.getsizeof({})) 5299 b.u, b.v, b.w, b.t, b.s, b.r = range(6) 5300 self.assertLess(sys.getsizeof(vars(b)), sys.getsizeof({})) 5301 5302 5303class DebugHelperMeta(type): 5304 """ 5305 Sets default __doc__ and simplifies repr() output. 5306 """ 5307 def __new__(mcls, name, bases, attrs): 5308 if attrs.get('__doc__') is None: 5309 attrs['__doc__'] = name # helps when debugging with gdb 5310 return type.__new__(mcls, name, bases, attrs) 5311 def __repr__(cls): 5312 return repr(cls.__name__) 5313 5314 5315class MroTest(unittest.TestCase): 5316 """ 5317 Regressions for some bugs revealed through 5318 mcsl.mro() customization (typeobject.c: mro_internal()) and 5319 cls.__bases__ assignment (typeobject.c: type_set_bases()). 5320 """ 5321 5322 def setUp(self): 5323 self.step = 0 5324 self.ready = False 5325 5326 def step_until(self, limit): 5327 ret = (self.step < limit) 5328 if ret: 5329 self.step += 1 5330 return ret 5331 5332 def test_incomplete_set_bases_on_self(self): 5333 """ 5334 type_set_bases must be aware that type->tp_mro can be NULL. 5335 """ 5336 class M(DebugHelperMeta): 5337 def mro(cls): 5338 if self.step_until(1): 5339 assert cls.__mro__ is None 5340 cls.__bases__ += () 5341 5342 return type.mro(cls) 5343 5344 class A(metaclass=M): 5345 pass 5346 5347 def test_reent_set_bases_on_base(self): 5348 """ 5349 Deep reentrancy must not over-decref old_mro. 5350 """ 5351 class M(DebugHelperMeta): 5352 def mro(cls): 5353 if cls.__mro__ is not None and cls.__name__ == 'B': 5354 # 4-5 steps are usually enough to make it crash somewhere 5355 if self.step_until(10): 5356 A.__bases__ += () 5357 5358 return type.mro(cls) 5359 5360 class A(metaclass=M): 5361 pass 5362 class B(A): 5363 pass 5364 B.__bases__ += () 5365 5366 def test_reent_set_bases_on_direct_base(self): 5367 """ 5368 Similar to test_reent_set_bases_on_base, but may crash differently. 5369 """ 5370 class M(DebugHelperMeta): 5371 def mro(cls): 5372 base = cls.__bases__[0] 5373 if base is not object: 5374 if self.step_until(5): 5375 base.__bases__ += () 5376 5377 return type.mro(cls) 5378 5379 class A(metaclass=M): 5380 pass 5381 class B(A): 5382 pass 5383 class C(B): 5384 pass 5385 5386 def test_reent_set_bases_tp_base_cycle(self): 5387 """ 5388 type_set_bases must check for an inheritance cycle not only through 5389 MRO of the type, which may be not yet updated in case of reentrance, 5390 but also through tp_base chain, which is assigned before diving into 5391 inner calls to mro(). 5392 5393 Otherwise, the following snippet can loop forever: 5394 do { 5395 // ... 5396 type = type->tp_base; 5397 } while (type != NULL); 5398 5399 Functions that rely on tp_base (like solid_base and PyType_IsSubtype) 5400 would not be happy in that case, causing a stack overflow. 5401 """ 5402 class M(DebugHelperMeta): 5403 def mro(cls): 5404 if self.ready: 5405 if cls.__name__ == 'B1': 5406 B2.__bases__ = (B1,) 5407 if cls.__name__ == 'B2': 5408 B1.__bases__ = (B2,) 5409 return type.mro(cls) 5410 5411 class A(metaclass=M): 5412 pass 5413 class B1(A): 5414 pass 5415 class B2(A): 5416 pass 5417 5418 self.ready = True 5419 with self.assertRaises(TypeError): 5420 B1.__bases__ += () 5421 5422 def test_tp_subclasses_cycle_in_update_slots(self): 5423 """ 5424 type_set_bases must check for reentrancy upon finishing its job 5425 by updating tp_subclasses of old/new bases of the type. 5426 Otherwise, an implicit inheritance cycle through tp_subclasses 5427 can break functions that recurse on elements of that field 5428 (like recurse_down_subclasses and mro_hierarchy) eventually 5429 leading to a stack overflow. 5430 """ 5431 class M(DebugHelperMeta): 5432 def mro(cls): 5433 if self.ready and cls.__name__ == 'C': 5434 self.ready = False 5435 C.__bases__ = (B2,) 5436 return type.mro(cls) 5437 5438 class A(metaclass=M): 5439 pass 5440 class B1(A): 5441 pass 5442 class B2(A): 5443 pass 5444 class C(A): 5445 pass 5446 5447 self.ready = True 5448 C.__bases__ = (B1,) 5449 B1.__bases__ = (C,) 5450 5451 self.assertEqual(C.__bases__, (B2,)) 5452 self.assertEqual(B2.__subclasses__(), [C]) 5453 self.assertEqual(B1.__subclasses__(), []) 5454 5455 self.assertEqual(B1.__bases__, (C,)) 5456 self.assertEqual(C.__subclasses__(), [B1]) 5457 5458 def test_tp_subclasses_cycle_error_return_path(self): 5459 """ 5460 The same as test_tp_subclasses_cycle_in_update_slots, but tests 5461 a code path executed on error (goto bail). 5462 """ 5463 class E(Exception): 5464 pass 5465 class M(DebugHelperMeta): 5466 def mro(cls): 5467 if self.ready and cls.__name__ == 'C': 5468 if C.__bases__ == (B2,): 5469 self.ready = False 5470 else: 5471 C.__bases__ = (B2,) 5472 raise E 5473 return type.mro(cls) 5474 5475 class A(metaclass=M): 5476 pass 5477 class B1(A): 5478 pass 5479 class B2(A): 5480 pass 5481 class C(A): 5482 pass 5483 5484 self.ready = True 5485 with self.assertRaises(E): 5486 C.__bases__ = (B1,) 5487 B1.__bases__ = (C,) 5488 5489 self.assertEqual(C.__bases__, (B2,)) 5490 self.assertEqual(C.__mro__, tuple(type.mro(C))) 5491 5492 def test_incomplete_extend(self): 5493 """ 5494 Extending an unitialized type with type->tp_mro == NULL must 5495 throw a reasonable TypeError exception, instead of failing 5496 with PyErr_BadInternalCall. 5497 """ 5498 class M(DebugHelperMeta): 5499 def mro(cls): 5500 if cls.__mro__ is None and cls.__name__ != 'X': 5501 with self.assertRaises(TypeError): 5502 class X(cls): 5503 pass 5504 5505 return type.mro(cls) 5506 5507 class A(metaclass=M): 5508 pass 5509 5510 def test_incomplete_super(self): 5511 """ 5512 Attrubute lookup on a super object must be aware that 5513 its target type can be uninitialized (type->tp_mro == NULL). 5514 """ 5515 class M(DebugHelperMeta): 5516 def mro(cls): 5517 if cls.__mro__ is None: 5518 with self.assertRaises(AttributeError): 5519 super(cls, cls).xxx 5520 5521 return type.mro(cls) 5522 5523 class A(metaclass=M): 5524 pass 5525 5526 5527def test_main(): 5528 # Run all local test cases, with PTypesLongInitTest first. 5529 support.run_unittest(PTypesLongInitTest, OperatorsTest, 5530 ClassPropertiesAndMethods, DictProxyTests, 5531 MiscTests, PicklingTests, SharedKeyTests, 5532 MroTest) 5533 5534if __name__ == "__main__": 5535 test_main() 5536