1 import builtins 2 import copyreg 3 import gc 4 import itertools 5 import math 6 import pickle 7 import sys 8 import types 9 import unittest 10 import warnings 11 import weakref 12 13 from copy import deepcopy 14 from test import support 15 16 17 class 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 387 class 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 966 order (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_descriptor(self): 1326 # Issue2115: slot descriptors did not correctly check 1327 # the type of the given object 1328 import abc 1329 class MyABC(metaclass=abc.ABCMeta): 1330 __slots__ = "a" 1331 1332 class Unrelated(object): 1333 pass 1334 MyABC.register(Unrelated) 1335 1336 u = Unrelated() 1337 self.assertIsInstance(u, MyABC) 1338 1339 # This used to crash 1340 self.assertRaises(TypeError, MyABC.a.__set__, u, 3) 1341 1342 def test_dynamics(self): 1343 # Testing class attribute propagation... 1344 class D(object): 1345 pass 1346 class E(D): 1347 pass 1348 class F(D): 1349 pass 1350 D.foo = 1 1351 self.assertEqual(D.foo, 1) 1352 # Test that dynamic attributes are inherited 1353 self.assertEqual(E.foo, 1) 1354 self.assertEqual(F.foo, 1) 1355 # Test dynamic instances 1356 class C(object): 1357 pass 1358 a = C() 1359 self.assertNotHasAttr(a, "foobar") 1360 C.foobar = 2 1361 self.assertEqual(a.foobar, 2) 1362 C.method = lambda self: 42 1363 self.assertEqual(a.method(), 42) 1364 C.__repr__ = lambda self: "C()" 1365 self.assertEqual(repr(a), "C()") 1366 C.__int__ = lambda self: 100 1367 self.assertEqual(int(a), 100) 1368 self.assertEqual(a.foobar, 2) 1369 self.assertNotHasAttr(a, "spam") 1370 def mygetattr(self, name): 1371 if name == "spam": 1372 return "spam" 1373 raise AttributeError 1374 C.__getattr__ = mygetattr 1375 self.assertEqual(a.spam, "spam") 1376 a.new = 12 1377 self.assertEqual(a.new, 12) 1378 def mysetattr(self, name, value): 1379 if name == "spam": 1380 raise AttributeError 1381 return object.__setattr__(self, name, value) 1382 C.__setattr__ = mysetattr 1383 try: 1384 a.spam = "not spam" 1385 except AttributeError: 1386 pass 1387 else: 1388 self.fail("expected AttributeError") 1389 self.assertEqual(a.spam, "spam") 1390 class D(C): 1391 pass 1392 d = D() 1393 d.foo = 1 1394 self.assertEqual(d.foo, 1) 1395 1396 # Test handling of int*seq and seq*int 1397 class I(int): 1398 pass 1399 self.assertEqual("a"*I(2), "aa") 1400 self.assertEqual(I(2)*"a", "aa") 1401 self.assertEqual(2*I(3), 6) 1402 self.assertEqual(I(3)*2, 6) 1403 self.assertEqual(I(3)*I(2), 6) 1404 1405 # Test comparison of classes with dynamic metaclasses 1406 class dynamicmetaclass(type): 1407 pass 1408 class someclass(metaclass=dynamicmetaclass): 1409 pass 1410 self.assertNotEqual(someclass, object) 1411 1412 def test_errors(self): 1413 # Testing errors... 1414 try: 1415 class C(list, dict): 1416 pass 1417 except TypeError: 1418 pass 1419 else: 1420 self.fail("inheritance from both list and dict should be illegal") 1421 1422 try: 1423 class C(object, None): 1424 pass 1425 except TypeError: 1426 pass 1427 else: 1428 self.fail("inheritance from non-type should be illegal") 1429 class Classic: 1430 pass 1431 1432 try: 1433 class C(type(len)): 1434 pass 1435 except TypeError: 1436 pass 1437 else: 1438 self.fail("inheritance from CFunction should be illegal") 1439 1440 try: 1441 class C(object): 1442 __slots__ = 1 1443 except TypeError: 1444 pass 1445 else: 1446 self.fail("__slots__ = 1 should be illegal") 1447 1448 try: 1449 class C(object): 1450 __slots__ = [1] 1451 except TypeError: 1452 pass 1453 else: 1454 self.fail("__slots__ = [1] should be illegal") 1455 1456 class M1(type): 1457 pass 1458 class M2(type): 1459 pass 1460 class A1(object, metaclass=M1): 1461 pass 1462 class A2(object, metaclass=M2): 1463 pass 1464 try: 1465 class B(A1, A2): 1466 pass 1467 except TypeError: 1468 pass 1469 else: 1470 self.fail("finding the most derived metaclass should have failed") 1471 1472 def test_classmethods(self): 1473 # Testing class methods... 1474 class C(object): 1475 def foo(*a): return a 1476 goo = classmethod(foo) 1477 c = C() 1478 self.assertEqual(C.goo(1), (C, 1)) 1479 self.assertEqual(c.goo(1), (C, 1)) 1480 self.assertEqual(c.foo(1), (c, 1)) 1481 class D(C): 1482 pass 1483 d = D() 1484 self.assertEqual(D.goo(1), (D, 1)) 1485 self.assertEqual(d.goo(1), (D, 1)) 1486 self.assertEqual(d.foo(1), (d, 1)) 1487 self.assertEqual(D.foo(d, 1), (d, 1)) 1488 # Test for a specific crash (SF bug 528132) 1489 def f(cls, arg): return (cls, arg) 1490 ff = classmethod(f) 1491 self.assertEqual(ff.__get__(0, int)(42), (int, 42)) 1492 self.assertEqual(ff.__get__(0)(42), (int, 42)) 1493 1494 # Test super() with classmethods (SF bug 535444) 1495 self.assertEqual(C.goo.__self__, C) 1496 self.assertEqual(D.goo.__self__, D) 1497 self.assertEqual(super(D,D).goo.__self__, D) 1498 self.assertEqual(super(D,d).goo.__self__, D) 1499 self.assertEqual(super(D,D).goo(), (D,)) 1500 self.assertEqual(super(D,d).goo(), (D,)) 1501 1502 # Verify that a non-callable will raise 1503 meth = classmethod(1).__get__(1) 1504 self.assertRaises(TypeError, meth) 1505 1506 # Verify that classmethod() doesn't allow keyword args 1507 try: 1508 classmethod(f, kw=1) 1509 except TypeError: 1510 pass 1511 else: 1512 self.fail("classmethod shouldn't accept keyword args") 1513 1514 cm = classmethod(f) 1515 self.assertEqual(cm.__dict__, {}) 1516 cm.x = 42 1517 self.assertEqual(cm.x, 42) 1518 self.assertEqual(cm.__dict__, {"x" : 42}) 1519 del cm.x 1520 self.assertNotHasAttr(cm, "x") 1521 1522 @support.impl_detail("the module 'xxsubtype' is internal") 1523 def test_classmethods_in_c(self): 1524 # Testing C-based class methods... 1525 import xxsubtype as spam 1526 a = (1, 2, 3) 1527 d = {'abc': 123} 1528 x, a1, d1 = spam.spamlist.classmeth(*a, **d) 1529 self.assertEqual(x, spam.spamlist) 1530 self.assertEqual(a, a1) 1531 self.assertEqual(d, d1) 1532 x, a1, d1 = spam.spamlist().classmeth(*a, **d) 1533 self.assertEqual(x, spam.spamlist) 1534 self.assertEqual(a, a1) 1535 self.assertEqual(d, d1) 1536 spam_cm = spam.spamlist.__dict__['classmeth'] 1537 x2, a2, d2 = spam_cm(spam.spamlist, *a, **d) 1538 self.assertEqual(x2, spam.spamlist) 1539 self.assertEqual(a2, a1) 1540 self.assertEqual(d2, d1) 1541 class SubSpam(spam.spamlist): pass 1542 x2, a2, d2 = spam_cm(SubSpam, *a, **d) 1543 self.assertEqual(x2, SubSpam) 1544 self.assertEqual(a2, a1) 1545 self.assertEqual(d2, d1) 1546 with self.assertRaises(TypeError): 1547 spam_cm() 1548 with self.assertRaises(TypeError): 1549 spam_cm(spam.spamlist()) 1550 with self.assertRaises(TypeError): 1551 spam_cm(list) 1552 1553 def test_staticmethods(self): 1554 # Testing static methods... 1555 class C(object): 1556 def foo(*a): return a 1557 goo = staticmethod(foo) 1558 c = C() 1559 self.assertEqual(C.goo(1), (1,)) 1560 self.assertEqual(c.goo(1), (1,)) 1561 self.assertEqual(c.foo(1), (c, 1,)) 1562 class D(C): 1563 pass 1564 d = D() 1565 self.assertEqual(D.goo(1), (1,)) 1566 self.assertEqual(d.goo(1), (1,)) 1567 self.assertEqual(d.foo(1), (d, 1)) 1568 self.assertEqual(D.foo(d, 1), (d, 1)) 1569 sm = staticmethod(None) 1570 self.assertEqual(sm.__dict__, {}) 1571 sm.x = 42 1572 self.assertEqual(sm.x, 42) 1573 self.assertEqual(sm.__dict__, {"x" : 42}) 1574 del sm.x 1575 self.assertNotHasAttr(sm, "x") 1576 1577 @support.impl_detail("the module 'xxsubtype' is internal") 1578 def test_staticmethods_in_c(self): 1579 # Testing C-based static methods... 1580 import xxsubtype as spam 1581 a = (1, 2, 3) 1582 d = {"abc": 123} 1583 x, a1, d1 = spam.spamlist.staticmeth(*a, **d) 1584 self.assertEqual(x, None) 1585 self.assertEqual(a, a1) 1586 self.assertEqual(d, d1) 1587 x, a1, d2 = spam.spamlist().staticmeth(*a, **d) 1588 self.assertEqual(x, None) 1589 self.assertEqual(a, a1) 1590 self.assertEqual(d, d1) 1591 1592 def test_classic(self): 1593 # Testing classic classes... 1594 class C: 1595 def foo(*a): return a 1596 goo = classmethod(foo) 1597 c = C() 1598 self.assertEqual(C.goo(1), (C, 1)) 1599 self.assertEqual(c.goo(1), (C, 1)) 1600 self.assertEqual(c.foo(1), (c, 1)) 1601 class D(C): 1602 pass 1603 d = D() 1604 self.assertEqual(D.goo(1), (D, 1)) 1605 self.assertEqual(d.goo(1), (D, 1)) 1606 self.assertEqual(d.foo(1), (d, 1)) 1607 self.assertEqual(D.foo(d, 1), (d, 1)) 1608 class E: # *not* subclassing from C 1609 foo = C.foo 1610 self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound 1611 self.assertTrue(repr(C.foo.__get__(C())).startswith("<bound method ")) 1612 1613 def test_compattr(self): 1614 # Testing computed attributes... 1615 class C(object): 1616 class computed_attribute(object): 1617 def __init__(self, get, set=None, delete=None): 1618 self.__get = get 1619 self.__set = set 1620 self.__delete = delete 1621 def __get__(self, obj, type=None): 1622 return self.__get(obj) 1623 def __set__(self, obj, value): 1624 return self.__set(obj, value) 1625 def __delete__(self, obj): 1626 return self.__delete(obj) 1627 def __init__(self): 1628 self.__x = 0 1629 def __get_x(self): 1630 x = self.__x 1631 self.__x = x+1 1632 return x 1633 def __set_x(self, x): 1634 self.__x = x 1635 def __delete_x(self): 1636 del self.__x 1637 x = computed_attribute(__get_x, __set_x, __delete_x) 1638 a = C() 1639 self.assertEqual(a.x, 0) 1640 self.assertEqual(a.x, 1) 1641 a.x = 10 1642 self.assertEqual(a.x, 10) 1643 self.assertEqual(a.x, 11) 1644 del a.x 1645 self.assertNotHasAttr(a, 'x') 1646 1647 def test_newslots(self): 1648 # Testing __new__ slot override... 1649 class C(list): 1650 def __new__(cls): 1651 self = list.__new__(cls) 1652 self.foo = 1 1653 return self 1654 def __init__(self): 1655 self.foo = self.foo + 2 1656 a = C() 1657 self.assertEqual(a.foo, 3) 1658 self.assertEqual(a.__class__, C) 1659 class D(C): 1660 pass 1661 b = D() 1662 self.assertEqual(b.foo, 3) 1663 self.assertEqual(b.__class__, D) 1664 1665 @unittest.expectedFailure 1666 def test_bad_new(self): 1667 self.assertRaises(TypeError, object.__new__) 1668 self.assertRaises(TypeError, object.__new__, '') 1669 self.assertRaises(TypeError, list.__new__, object) 1670 self.assertRaises(TypeError, object.__new__, list) 1671 class C(object): 1672 __new__ = list.__new__ 1673 self.assertRaises(TypeError, C) 1674 class C(list): 1675 __new__ = object.__new__ 1676 self.assertRaises(TypeError, C) 1677 1678 def test_object_new(self): 1679 class A(object): 1680 pass 1681 object.__new__(A) 1682 self.assertRaises(TypeError, object.__new__, A, 5) 1683 object.__init__(A()) 1684 self.assertRaises(TypeError, object.__init__, A(), 5) 1685 1686 class A(object): 1687 def __init__(self, foo): 1688 self.foo = foo 1689 object.__new__(A) 1690 object.__new__(A, 5) 1691 object.__init__(A(3)) 1692 self.assertRaises(TypeError, object.__init__, A(3), 5) 1693 1694 class A(object): 1695 def __new__(cls, foo): 1696 return object.__new__(cls) 1697 object.__new__(A) 1698 self.assertRaises(TypeError, object.__new__, A, 5) 1699 object.__init__(A(3)) 1700 object.__init__(A(3), 5) 1701 1702 class A(object): 1703 def __new__(cls, foo): 1704 return object.__new__(cls) 1705 def __init__(self, foo): 1706 self.foo = foo 1707 object.__new__(A) 1708 self.assertRaises(TypeError, object.__new__, A, 5) 1709 object.__init__(A(3)) 1710 self.assertRaises(TypeError, object.__init__, A(3), 5) 1711 1712 @unittest.expectedFailure 1713 def test_restored_object_new(self): 1714 class A(object): 1715 def __new__(cls, *args, **kwargs): 1716 raise AssertionError 1717 self.assertRaises(AssertionError, A) 1718 class B(A): 1719 __new__ = object.__new__ 1720 def __init__(self, foo): 1721 self.foo = foo 1722 with warnings.catch_warnings(): 1723 warnings.simplefilter('error', DeprecationWarning) 1724 b = B(3) 1725 self.assertEqual(b.foo, 3) 1726 self.assertEqual(b.__class__, B) 1727 del B.__new__ 1728 self.assertRaises(AssertionError, B) 1729 del A.__new__ 1730 with warnings.catch_warnings(): 1731 warnings.simplefilter('error', DeprecationWarning) 1732 b = B(3) 1733 self.assertEqual(b.foo, 3) 1734 self.assertEqual(b.__class__, B) 1735 1736 def test_altmro(self): 1737 # Testing mro() and overriding it... 1738 class A(object): 1739 def f(self): return "A" 1740 class B(A): 1741 pass 1742 class C(A): 1743 def f(self): return "C" 1744 class D(B, C): 1745 pass 1746 self.assertEqual(D.mro(), [D, B, C, A, object]) 1747 self.assertEqual(D.__mro__, (D, B, C, A, object)) 1748 self.assertEqual(D().f(), "C") 1749 1750 class PerverseMetaType(type): 1751 def mro(cls): 1752 L = type.mro(cls) 1753 L.reverse() 1754 return L 1755 class X(D,B,C,A, metaclass=PerverseMetaType): 1756 pass 1757 self.assertEqual(X.__mro__, (object, A, C, B, D, X)) 1758 self.assertEqual(X().f(), "A") 1759 1760 try: 1761 class _metaclass(type): 1762 def mro(self): 1763 return [self, dict, object] 1764 class X(object, metaclass=_metaclass): 1765 pass 1766 # In CPython, the class creation above already raises 1767 # TypeError, as a protection against the fact that 1768 # instances of X would segfault it. In other Python 1769 # implementations it would be ok to let the class X 1770 # be created, but instead get a clean TypeError on the 1771 # __setitem__ below. 1772 x = object.__new__(X) 1773 x[5] = 6 1774 except TypeError: 1775 pass 1776 else: 1777 self.fail("devious mro() return not caught") 1778 1779 try: 1780 class _metaclass(type): 1781 def mro(self): 1782 return [1] 1783 class X(object, metaclass=_metaclass): 1784 pass 1785 except TypeError: 1786 pass 1787 else: 1788 self.fail("non-class mro() return not caught") 1789 1790 try: 1791 class _metaclass(type): 1792 def mro(self): 1793 return 1 1794 class X(object, metaclass=_metaclass): 1795 pass 1796 except TypeError: 1797 pass 1798 else: 1799 self.fail("non-sequence mro() return not caught") 1800 1801 def test_overloading(self): 1802 # Testing operator overloading... 1803 1804 class B(object): 1805 "Intermediate class because object doesn't have a __setattr__" 1806 1807 class C(B): 1808 def __getattr__(self, name): 1809 if name == "foo": 1810 return ("getattr", name) 1811 else: 1812 raise AttributeError 1813 def __setattr__(self, name, value): 1814 if name == "foo": 1815 self.setattr = (name, value) 1816 else: 1817 return B.__setattr__(self, name, value) 1818 def __delattr__(self, name): 1819 if name == "foo": 1820 self.delattr = name 1821 else: 1822 return B.__delattr__(self, name) 1823 1824 def __getitem__(self, key): 1825 return ("getitem", key) 1826 def __setitem__(self, key, value): 1827 self.setitem = (key, value) 1828 def __delitem__(self, key): 1829 self.delitem = key 1830 1831 a = C() 1832 self.assertEqual(a.foo, ("getattr", "foo")) 1833 a.foo = 12 1834 self.assertEqual(a.setattr, ("foo", 12)) 1835 del a.foo 1836 self.assertEqual(a.delattr, "foo") 1837 1838 self.assertEqual(a[12], ("getitem", 12)) 1839 a[12] = 21 1840 self.assertEqual(a.setitem, (12, 21)) 1841 del a[12] 1842 self.assertEqual(a.delitem, 12) 1843 1844 self.assertEqual(a[0:10], ("getitem", slice(0, 10))) 1845 a[0:10] = "foo" 1846 self.assertEqual(a.setitem, (slice(0, 10), "foo")) 1847 del a[0:10] 1848 self.assertEqual(a.delitem, (slice(0, 10))) 1849 1850 def test_methods(self): 1851 # Testing methods... 1852 class C(object): 1853 def __init__(self, x): 1854 self.x = x 1855 def foo(self): 1856 return self.x 1857 c1 = C(1) 1858 self.assertEqual(c1.foo(), 1) 1859 class D(C): 1860 boo = C.foo 1861 goo = c1.foo 1862 d2 = D(2) 1863 self.assertEqual(d2.foo(), 2) 1864 self.assertEqual(d2.boo(), 2) 1865 self.assertEqual(d2.goo(), 1) 1866 class E(object): 1867 foo = C.foo 1868 self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound 1869 self.assertTrue(repr(C.foo.__get__(C(1))).startswith("<bound method ")) 1870 1871 def test_special_method_lookup(self): 1872 # The lookup of special methods bypasses __getattr__ and 1873 # __getattribute__, but they still can be descriptors. 1874 1875 def run_context(manager): 1876 with manager: 1877 pass 1878 def iden(self): 1879 return self 1880 def hello(self): 1881 return b"hello" 1882 def empty_seq(self): 1883 return [] 1884 def zero(self): 1885 return 0 1886 def complex_num(self): 1887 return 1j 1888 def stop(self): 1889 raise StopIteration 1890 def return_true(self, thing=None): 1891 return True 1892 def do_isinstance(obj): 1893 return isinstance(int, obj) 1894 def do_issubclass(obj): 1895 return issubclass(int, obj) 1896 def do_dict_missing(checker): 1897 class DictSub(checker.__class__, dict): 1898 pass 1899 self.assertEqual(DictSub()["hi"], 4) 1900 def some_number(self_, key): 1901 self.assertEqual(key, "hi") 1902 return 4 1903 def swallow(*args): pass 1904 def format_impl(self, spec): 1905 return "hello" 1906 1907 # It would be nice to have every special method tested here, but I'm 1908 # only listing the ones I can remember outside of typeobject.c, since it 1909 # does it right. 1910 specials = [ 1911 ("__bytes__", bytes, hello, set(), {}), 1912 ("__reversed__", reversed, empty_seq, set(), {}), 1913 ("__length_hint__", list, zero, set(), 1914 {"__iter__" : iden, "__next__" : stop}), 1915 ("__sizeof__", sys.getsizeof, zero, set(), {}), 1916 ("__instancecheck__", do_isinstance, return_true, set(), {}), 1917 ("__missing__", do_dict_missing, some_number, 1918 set(("__class__",)), {}), 1919 ("__subclasscheck__", do_issubclass, return_true, 1920 set(("__bases__",)), {}), 1921 ("__enter__", run_context, iden, set(), {"__exit__" : swallow}), 1922 ("__exit__", run_context, swallow, set(), {"__enter__" : iden}), 1923 ("__complex__", complex, complex_num, set(), {}), 1924 ("__format__", format, format_impl, set(), {}), 1925 ("__floor__", math.floor, zero, set(), {}), 1926 ("__trunc__", math.trunc, zero, set(), {}), 1927 ("__trunc__", int, zero, set(), {}), 1928 ("__ceil__", math.ceil, zero, set(), {}), 1929 ("__dir__", dir, empty_seq, set(), {}), 1930 ("__round__", round, zero, set(), {}), 1931 ] 1932 1933 class Checker(object): 1934 def __getattr__(self, attr, test=self): 1935 test.fail("__getattr__ called with {0}".format(attr)) 1936 def __getattribute__(self, attr, test=self): 1937 if attr not in ok: 1938 test.fail("__getattribute__ called with {0}".format(attr)) 1939 return object.__getattribute__(self, attr) 1940 class SpecialDescr(object): 1941 def __init__(self, impl): 1942 self.impl = impl 1943 def __get__(self, obj, owner): 1944 record.append(1) 1945 return self.impl.__get__(obj, owner) 1946 class MyException(Exception): 1947 pass 1948 class ErrDescr(object): 1949 def __get__(self, obj, owner): 1950 raise MyException 1951 1952 for name, runner, meth_impl, ok, env in specials: 1953 class X(Checker): 1954 pass 1955 for attr, obj in env.items(): 1956 setattr(X, attr, obj) 1957 setattr(X, name, meth_impl) 1958 runner(X()) 1959 1960 record = [] 1961 class X(Checker): 1962 pass 1963 for attr, obj in env.items(): 1964 setattr(X, attr, obj) 1965 setattr(X, name, SpecialDescr(meth_impl)) 1966 runner(X()) 1967 self.assertEqual(record, [1], name) 1968 1969 class X(Checker): 1970 pass 1971 for attr, obj in env.items(): 1972 setattr(X, attr, obj) 1973 setattr(X, name, ErrDescr()) 1974 self.assertRaises(MyException, runner, X()) 1975 1976 def test_specials(self): 1977 # Testing special operators... 1978 # Test operators like __hash__ for which a built-in default exists 1979 1980 # Test the default behavior for static classes 1981 class C(object): 1982 def __getitem__(self, i): 1983 if 0 <= i < 10: return i 1984 raise IndexError 1985 c1 = C() 1986 c2 = C() 1987 self.assertFalse(not c1) 1988 self.assertNotEqual(id(c1), id(c2)) 1989 hash(c1) 1990 hash(c2) 1991 self.assertEqual(c1, c1) 1992 self.assertTrue(c1 != c2) 1993 self.assertFalse(c1 != c1) 1994 self.assertFalse(c1 == c2) 1995 # Note that the module name appears in str/repr, and that varies 1996 # depending on whether this test is run standalone or from a framework. 1997 self.assertGreaterEqual(str(c1).find('C object at '), 0) 1998 self.assertEqual(str(c1), repr(c1)) 1999 self.assertNotIn(-1, c1) 2000 for i in range(10): 2001 self.assertIn(i, c1) 2002 self.assertNotIn(10, c1) 2003 # Test the default behavior for dynamic classes 2004 class D(object): 2005 def __getitem__(self, i): 2006 if 0 <= i < 10: return i 2007 raise IndexError 2008 d1 = D() 2009 d2 = D() 2010 self.assertFalse(not d1) 2011 self.assertNotEqual(id(d1), id(d2)) 2012 hash(d1) 2013 hash(d2) 2014 self.assertEqual(d1, d1) 2015 self.assertNotEqual(d1, d2) 2016 self.assertFalse(d1 != d1) 2017 self.assertFalse(d1 == d2) 2018 # Note that the module name appears in str/repr, and that varies 2019 # depending on whether this test is run standalone or from a framework. 2020 self.assertGreaterEqual(str(d1).find('D object at '), 0) 2021 self.assertEqual(str(d1), repr(d1)) 2022 self.assertNotIn(-1, d1) 2023 for i in range(10): 2024 self.assertIn(i, d1) 2025 self.assertNotIn(10, d1) 2026 # Test overridden behavior 2027 class Proxy(object): 2028 def __init__(self, x): 2029 self.x = x 2030 def __bool__(self): 2031 return not not self.x 2032 def __hash__(self): 2033 return hash(self.x) 2034 def __eq__(self, other): 2035 return self.x == other 2036 def __ne__(self, other): 2037 return self.x != other 2038 def __ge__(self, other): 2039 return self.x >= other 2040 def __gt__(self, other): 2041 return self.x > other 2042 def __le__(self, other): 2043 return self.x <= other 2044 def __lt__(self, other): 2045 return self.x < other 2046 def __str__(self): 2047 return "Proxy:%s" % self.x 2048 def __repr__(self): 2049 return "Proxy(%r)" % self.x 2050 def __contains__(self, value): 2051 return value in self.x 2052 p0 = Proxy(0) 2053 p1 = Proxy(1) 2054 p_1 = Proxy(-1) 2055 self.assertFalse(p0) 2056 self.assertFalse(not p1) 2057 self.assertEqual(hash(p0), hash(0)) 2058 self.assertEqual(p0, p0) 2059 self.assertNotEqual(p0, p1) 2060 self.assertFalse(p0 != p0) 2061 self.assertEqual(not p0, p1) 2062 self.assertTrue(p0 < p1) 2063 self.assertTrue(p0 <= p1) 2064 self.assertTrue(p1 > p0) 2065 self.assertTrue(p1 >= p0) 2066 self.assertEqual(str(p0), "Proxy:0") 2067 self.assertEqual(repr(p0), "Proxy(0)") 2068 p10 = Proxy(range(10)) 2069 self.assertNotIn(-1, p10) 2070 for i in range(10): 2071 self.assertIn(i, p10) 2072 self.assertNotIn(10, p10) 2073 2074 def test_weakrefs(self): 2075 # Testing weak references... 2076 import weakref 2077 class C(object): 2078 pass 2079 c = C() 2080 r = weakref.ref(c) 2081 self.assertEqual(r(), c) 2082 del c 2083 support.gc_collect() 2084 self.assertEqual(r(), None) 2085 del r 2086 class NoWeak(object): 2087 __slots__ = ['foo'] 2088 no = NoWeak() 2089 try: 2090 weakref.ref(no) 2091 except TypeError as msg: 2092 self.assertIn("weak reference", str(msg)) 2093 else: 2094 self.fail("weakref.ref(no) should be illegal") 2095 class Weak(object): 2096 __slots__ = ['foo', '__weakref__'] 2097 yes = Weak() 2098 r = weakref.ref(yes) 2099 self.assertEqual(r(), yes) 2100 del yes 2101 support.gc_collect() 2102 self.assertEqual(r(), None) 2103 del r 2104 2105 def test_properties(self): 2106 # Testing property... 2107 class C(object): 2108 def getx(self): 2109 return self.__x 2110 def setx(self, value): 2111 self.__x = value 2112 def delx(self): 2113 del self.__x 2114 x = property(getx, setx, delx, doc="I'm the x property.") 2115 a = C() 2116 self.assertNotHasAttr(a, "x") 2117 a.x = 42 2118 self.assertEqual(a._C__x, 42) 2119 self.assertEqual(a.x, 42) 2120 del a.x 2121 self.assertNotHasAttr(a, "x") 2122 self.assertNotHasAttr(a, "_C__x") 2123 C.x.__set__(a, 100) 2124 self.assertEqual(C.x.__get__(a), 100) 2125 C.x.__delete__(a) 2126 self.assertNotHasAttr(a, "x") 2127 2128 raw = C.__dict__['x'] 2129 self.assertIsInstance(raw, property) 2130 2131 attrs = dir(raw) 2132 self.assertIn("__doc__", attrs) 2133 self.assertIn("fget", attrs) 2134 self.assertIn("fset", attrs) 2135 self.assertIn("fdel", attrs) 2136 2137 self.assertEqual(raw.__doc__, "I'm the x property.") 2138 self.assertIs(raw.fget, C.__dict__['getx']) 2139 self.assertIs(raw.fset, C.__dict__['setx']) 2140 self.assertIs(raw.fdel, C.__dict__['delx']) 2141 2142 for attr in "fget", "fset", "fdel": 2143 try: 2144 setattr(raw, attr, 42) 2145 except AttributeError as msg: 2146 if str(msg).find('readonly') < 0: 2147 self.fail("when setting readonly attr %r on a property, " 2148 "got unexpected AttributeError msg %r" % (attr, str(msg))) 2149 else: 2150 self.fail("expected AttributeError from trying to set readonly %r " 2151 "attr on a property" % attr) 2152 2153 raw.__doc__ = 42 2154 self.assertEqual(raw.__doc__, 42) 2155 2156 class D(object): 2157 __getitem__ = property(lambda s: 1/0) 2158 2159 d = D() 2160 try: 2161 for i in d: 2162 str(i) 2163 except ZeroDivisionError: 2164 pass 2165 else: 2166 self.fail("expected ZeroDivisionError from bad property") 2167 2168 @unittest.skipIf(sys.flags.optimize >= 2, 2169 "Docstrings are omitted with -O2 and above") 2170 def test_properties_doc_attrib(self): 2171 class E(object): 2172 def getter(self): 2173 "getter method" 2174 return 0 2175 def setter(self_, value): 2176 "setter method" 2177 pass 2178 prop = property(getter) 2179 self.assertEqual(prop.__doc__, "getter method") 2180 prop2 = property(fset=setter) 2181 self.assertEqual(prop2.__doc__, None) 2182 2183 @support.cpython_only 2184 def test_testcapi_no_segfault(self): 2185 # this segfaulted in 2.5b2 2186 try: 2187 import _testcapi 2188 except ImportError: 2189 pass 2190 else: 2191 class X(object): 2192 p = property(_testcapi.test_with_docstring) 2193 2194 def test_properties_plus(self): 2195 class C(object): 2196 foo = property(doc="hello") 2197 @foo.getter 2198 def foo(self): 2199 return self._foo 2200 @foo.setter 2201 def foo(self, value): 2202 self._foo = abs(value) 2203 @foo.deleter 2204 def foo(self): 2205 del self._foo 2206 c = C() 2207 self.assertEqual(C.foo.__doc__, "hello") 2208 self.assertNotHasAttr(c, "foo") 2209 c.foo = -42 2210 self.assertHasAttr(c, '_foo') 2211 self.assertEqual(c._foo, 42) 2212 self.assertEqual(c.foo, 42) 2213 del c.foo 2214 self.assertNotHasAttr(c, '_foo') 2215 self.assertNotHasAttr(c, "foo") 2216 2217 class D(C): 2218 @C.foo.deleter 2219 def foo(self): 2220 try: 2221 del self._foo 2222 except AttributeError: 2223 pass 2224 d = D() 2225 d.foo = 24 2226 self.assertEqual(d.foo, 24) 2227 del d.foo 2228 del d.foo 2229 2230 class E(object): 2231 @property 2232 def foo(self): 2233 return self._foo 2234 @foo.setter 2235 def foo(self, value): 2236 raise RuntimeError 2237 @foo.setter 2238 def foo(self, value): 2239 self._foo = abs(value) 2240 @foo.deleter 2241 def foo(self, value=None): 2242 del self._foo 2243 2244 e = E() 2245 e.foo = -42 2246 self.assertEqual(e.foo, 42) 2247 del e.foo 2248 2249 class F(E): 2250 @E.foo.deleter 2251 def foo(self): 2252 del self._foo 2253 @foo.setter 2254 def foo(self, value): 2255 self._foo = max(0, value) 2256 f = F() 2257 f.foo = -10 2258 self.assertEqual(f.foo, 0) 2259 del f.foo 2260 2261 def test_dict_constructors(self): 2262 # Testing dict constructor ... 2263 d = dict() 2264 self.assertEqual(d, {}) 2265 d = dict({}) 2266 self.assertEqual(d, {}) 2267 d = dict({1: 2, 'a': 'b'}) 2268 self.assertEqual(d, {1: 2, 'a': 'b'}) 2269 self.assertEqual(d, dict(list(d.items()))) 2270 self.assertEqual(d, dict(iter(d.items()))) 2271 d = dict({'one':1, 'two':2}) 2272 self.assertEqual(d, dict(one=1, two=2)) 2273 self.assertEqual(d, dict(**d)) 2274 self.assertEqual(d, dict({"one": 1}, two=2)) 2275 self.assertEqual(d, dict([("two", 2)], one=1)) 2276 self.assertEqual(d, dict([("one", 100), ("two", 200)], **d)) 2277 self.assertEqual(d, dict(**d)) 2278 2279 for badarg in 0, 0, 0j, "0", [0], (0,): 2280 try: 2281 dict(badarg) 2282 except TypeError: 2283 pass 2284 except ValueError: 2285 if badarg == "0": 2286 # It's a sequence, and its elements are also sequences (gotta 2287 # love strings <wink>), but they aren't of length 2, so this 2288 # one seemed better as a ValueError than a TypeError. 2289 pass 2290 else: 2291 self.fail("no TypeError from dict(%r)" % badarg) 2292 else: 2293 self.fail("no TypeError from dict(%r)" % badarg) 2294 2295 try: 2296 dict({}, {}) 2297 except TypeError: 2298 pass 2299 else: 2300 self.fail("no TypeError from dict({}, {})") 2301 2302 class Mapping: 2303 # Lacks a .keys() method; will be added later. 2304 dict = {1:2, 3:4, 'a':1j} 2305 2306 try: 2307 dict(Mapping()) 2308 except TypeError: 2309 pass 2310 else: 2311 self.fail("no TypeError from dict(incomplete mapping)") 2312 2313 Mapping.keys = lambda self: list(self.dict.keys()) 2314 Mapping.__getitem__ = lambda self, i: self.dict[i] 2315 d = dict(Mapping()) 2316 self.assertEqual(d, Mapping.dict) 2317 2318 # Init from sequence of iterable objects, each producing a 2-sequence. 2319 class AddressBookEntry: 2320 def __init__(self, first, last): 2321 self.first = first 2322 self.last = last 2323 def __iter__(self): 2324 return iter([self.first, self.last]) 2325 2326 d = dict([AddressBookEntry('Tim', 'Warsaw'), 2327 AddressBookEntry('Barry', 'Peters'), 2328 AddressBookEntry('Tim', 'Peters'), 2329 AddressBookEntry('Barry', 'Warsaw')]) 2330 self.assertEqual(d, {'Barry': 'Warsaw', 'Tim': 'Peters'}) 2331 2332 d = dict(zip(range(4), range(1, 5))) 2333 self.assertEqual(d, dict([(i, i+1) for i in range(4)])) 2334 2335 # Bad sequence lengths. 2336 for bad in [('tooshort',)], [('too', 'long', 'by 1')]: 2337 try: 2338 dict(bad) 2339 except ValueError: 2340 pass 2341 else: 2342 self.fail("no ValueError from dict(%r)" % bad) 2343 2344 def test_dir(self): 2345 # Testing dir() ... 2346 junk = 12 2347 self.assertEqual(dir(), ['junk', 'self']) 2348 del junk 2349 2350 # Just make sure these don't blow up! 2351 for arg in 2, 2, 2j, 2e0, [2], "2", b"2", (2,), {2:2}, type, self.test_dir: 2352 dir(arg) 2353 2354 # Test dir on new-style classes. Since these have object as a 2355 # base class, a lot more gets sucked in. 2356 def interesting(strings): 2357 return [s for s in strings if not s.startswith('_')] 2358 2359 class C(object): 2360 Cdata = 1 2361 def Cmethod(self): pass 2362 2363 cstuff = ['Cdata', 'Cmethod'] 2364 self.assertEqual(interesting(dir(C)), cstuff) 2365 2366 c = C() 2367 self.assertEqual(interesting(dir(c)), cstuff) 2368 ## self.assertIn('__self__', dir(C.Cmethod)) 2369 2370 c.cdata = 2 2371 c.cmethod = lambda self: 0 2372 self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod']) 2373 ## self.assertIn('__self__', dir(c.Cmethod)) 2374 2375 class A(C): 2376 Adata = 1 2377 def Amethod(self): pass 2378 2379 astuff = ['Adata', 'Amethod'] + cstuff 2380 self.assertEqual(interesting(dir(A)), astuff) 2381 ## self.assertIn('__self__', dir(A.Amethod)) 2382 a = A() 2383 self.assertEqual(interesting(dir(a)), astuff) 2384 a.adata = 42 2385 a.amethod = lambda self: 3 2386 self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod']) 2387 ## self.assertIn('__self__', dir(a.Amethod)) 2388 2389 # Try a module subclass. 2390 class M(type(sys)): 2391 pass 2392 minstance = M("m") 2393 minstance.b = 2 2394 minstance.a = 1 2395 default_attributes = ['__name__', '__doc__', '__package__', 2396 '__loader__', '__spec__'] 2397 names = [x for x in dir(minstance) if x not in default_attributes] 2398 self.assertEqual(names, ['a', 'b']) 2399 2400 class M2(M): 2401 def getdict(self): 2402 return "Not a dict!" 2403 __dict__ = property(getdict) 2404 2405 m2instance = M2("m2") 2406 m2instance.b = 2 2407 m2instance.a = 1 2408 self.assertEqual(m2instance.__dict__, "Not a dict!") 2409 try: 2410 dir(m2instance) 2411 except TypeError: 2412 pass 2413 2414 # Two essentially featureless objects, just inheriting stuff from 2415 # object. 2416 self.assertEqual(dir(NotImplemented), dir(Ellipsis)) 2417 2418 # Nasty test case for proxied objects 2419 class Wrapper(object): 2420 def __init__(self, obj): 2421 self.__obj = obj 2422 def __repr__(self): 2423 return "Wrapper(%s)" % repr(self.__obj) 2424 def __getitem__(self, key): 2425 return Wrapper(self.__obj[key]) 2426 def __len__(self): 2427 return len(self.__obj) 2428 def __getattr__(self, name): 2429 return Wrapper(getattr(self.__obj, name)) 2430 2431 class C(object): 2432 def __getclass(self): 2433 return Wrapper(type(self)) 2434 __class__ = property(__getclass) 2435 2436 dir(C()) # This used to segfault 2437 2438 def test_supers(self): 2439 # Testing super... 2440 2441 class A(object): 2442 def meth(self, a): 2443 return "A(%r)" % a 2444 2445 self.assertEqual(A().meth(1), "A(1)") 2446 2447 class B(A): 2448 def __init__(self): 2449 self.__super = super(B, self) 2450 def meth(self, a): 2451 return "B(%r)" % a + self.__super.meth(a) 2452 2453 self.assertEqual(B().meth(2), "B(2)A(2)") 2454 2455 class C(A): 2456 def meth(self, a): 2457 return "C(%r)" % a + self.__super.meth(a) 2458 C._C__super = super(C) 2459 2460 self.assertEqual(C().meth(3), "C(3)A(3)") 2461 2462 class D(C, B): 2463 def meth(self, a): 2464 return "D(%r)" % a + super(D, self).meth(a) 2465 2466 self.assertEqual(D().meth(4), "D(4)C(4)B(4)A(4)") 2467 2468 # Test for subclassing super 2469 2470 class mysuper(super): 2471 def __init__(self, *args): 2472 return super(mysuper, self).__init__(*args) 2473 2474 class E(D): 2475 def meth(self, a): 2476 return "E(%r)" % a + mysuper(E, self).meth(a) 2477 2478 self.assertEqual(E().meth(5), "E(5)D(5)C(5)B(5)A(5)") 2479 2480 class F(E): 2481 def meth(self, a): 2482 s = self.__super # == mysuper(F, self) 2483 return "F(%r)[%s]" % (a, s.__class__.__name__) + s.meth(a) 2484 F._F__super = mysuper(F) 2485 2486 self.assertEqual(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)") 2487 2488 # Make sure certain errors are raised 2489 2490 try: 2491 super(D, 42) 2492 except TypeError: 2493 pass 2494 else: 2495 self.fail("shouldn't allow super(D, 42)") 2496 2497 try: 2498 super(D, C()) 2499 except TypeError: 2500 pass 2501 else: 2502 self.fail("shouldn't allow super(D, C())") 2503 2504 try: 2505 super(D).__get__(12) 2506 except TypeError: 2507 pass 2508 else: 2509 self.fail("shouldn't allow super(D).__get__(12)") 2510 2511 try: 2512 super(D).__get__(C()) 2513 except TypeError: 2514 pass 2515 else: 2516 self.fail("shouldn't allow super(D).__get__(C())") 2517 2518 # Make sure data descriptors can be overridden and accessed via super 2519 # (new feature in Python 2.3) 2520 2521 class DDbase(object): 2522 def getx(self): return 42 2523 x = property(getx) 2524 2525 class DDsub(DDbase): 2526 def getx(self): return "hello" 2527 x = property(getx) 2528 2529 dd = DDsub() 2530 self.assertEqual(dd.x, "hello") 2531 self.assertEqual(super(DDsub, dd).x, 42) 2532 2533 # Ensure that super() lookup of descriptor from classmethod 2534 # works (SF ID# 743627) 2535 2536 class Base(object): 2537 aProp = property(lambda self: "foo") 2538 2539 class Sub(Base): 2540 @classmethod 2541 def test(klass): 2542 return super(Sub,klass).aProp 2543 2544 self.assertEqual(Sub.test(), Base.aProp) 2545 2546 # Verify that super() doesn't allow keyword args 2547 try: 2548 super(Base, kw=1) 2549 except TypeError: 2550 pass 2551 else: 2552 self.assertEqual("super shouldn't accept keyword args") 2553 2554 def test_basic_inheritance(self): 2555 # Testing inheritance from basic types... 2556 2557 class hexint(int): 2558 def __repr__(self): 2559 return hex(self) 2560 def __add__(self, other): 2561 return hexint(int.__add__(self, other)) 2562 # (Note that overriding __radd__ doesn't work, 2563 # because the int type gets first dibs.) 2564 self.assertEqual(repr(hexint(7) + 9), "0x10") 2565 self.assertEqual(repr(hexint(1000) + 7), "0x3ef") 2566 a = hexint(12345) 2567 self.assertEqual(a, 12345) 2568 self.assertEqual(int(a), 12345) 2569 self.assertIs(int(a).__class__, int) 2570 self.assertEqual(hash(a), hash(12345)) 2571 self.assertIs((+a).__class__, int) 2572 self.assertIs((a >> 0).__class__, int) 2573 self.assertIs((a << 0).__class__, int) 2574 self.assertIs((hexint(0) << 12).__class__, int) 2575 self.assertIs((hexint(0) >> 12).__class__, int) 2576 2577 class octlong(int): 2578 __slots__ = [] 2579 def __str__(self): 2580 return oct(self) 2581 def __add__(self, other): 2582 return self.__class__(super(octlong, self).__add__(other)) 2583 __radd__ = __add__ 2584 self.assertEqual(str(octlong(3) + 5), "0o10") 2585 # (Note that overriding __radd__ here only seems to work 2586 # because the example uses a short int left argument.) 2587 self.assertEqual(str(5 + octlong(3000)), "0o5675") 2588 a = octlong(12345) 2589 self.assertEqual(a, 12345) 2590 self.assertEqual(int(a), 12345) 2591 self.assertEqual(hash(a), hash(12345)) 2592 self.assertIs(int(a).__class__, int) 2593 self.assertIs((+a).__class__, int) 2594 self.assertIs((-a).__class__, int) 2595 self.assertIs((-octlong(0)).__class__, int) 2596 self.assertIs((a >> 0).__class__, int) 2597 self.assertIs((a << 0).__class__, int) 2598 self.assertIs((a - 0).__class__, int) 2599 self.assertIs((a * 1).__class__, int) 2600 self.assertIs((a ** 1).__class__, int) 2601 self.assertIs((a // 1).__class__, int) 2602 self.assertIs((1 * a).__class__, int) 2603 self.assertIs((a | 0).__class__, int) 2604 self.assertIs((a ^ 0).__class__, int) 2605 self.assertIs((a & -1).__class__, int) 2606 self.assertIs((octlong(0) << 12).__class__, int) 2607 self.assertIs((octlong(0) >> 12).__class__, int) 2608 self.assertIs(abs(octlong(0)).__class__, int) 2609 2610 # Because octlong overrides __add__, we can't check the absence of +0 2611 # optimizations using octlong. 2612 class longclone(int): 2613 pass 2614 a = longclone(1) 2615 self.assertIs((a + 0).__class__, int) 2616 self.assertIs((0 + a).__class__, int) 2617 2618 # Check that negative clones don't segfault 2619 a = longclone(-1) 2620 self.assertEqual(a.__dict__, {}) 2621 self.assertEqual(int(a), -1) # self.assertTrue PyNumber_Long() copies the sign bit 2622 2623 class precfloat(float): 2624 __slots__ = ['prec'] 2625 def __init__(self, value=0.0, prec=12): 2626 self.prec = int(prec) 2627 def __repr__(self): 2628 return "%.*g" % (self.prec, self) 2629 self.assertEqual(repr(precfloat(1.1)), "1.1") 2630 a = precfloat(12345) 2631 self.assertEqual(a, 12345.0) 2632 self.assertEqual(float(a), 12345.0) 2633 self.assertIs(float(a).__class__, float) 2634 self.assertEqual(hash(a), hash(12345.0)) 2635 self.assertIs((+a).__class__, float) 2636 2637 class madcomplex(complex): 2638 def __repr__(self): 2639 return "%.17gj%+.17g" % (self.imag, self.real) 2640 a = madcomplex(-3, 4) 2641 self.assertEqual(repr(a), "4j-3") 2642 base = complex(-3, 4) 2643 self.assertEqual(base.__class__, complex) 2644 self.assertEqual(a, base) 2645 self.assertEqual(complex(a), base) 2646 self.assertEqual(complex(a).__class__, complex) 2647 a = madcomplex(a) # just trying another form of the constructor 2648 self.assertEqual(repr(a), "4j-3") 2649 self.assertEqual(a, base) 2650 self.assertEqual(complex(a), base) 2651 self.assertEqual(complex(a).__class__, complex) 2652 self.assertEqual(hash(a), hash(base)) 2653 self.assertEqual((+a).__class__, complex) 2654 self.assertEqual((a + 0).__class__, complex) 2655 self.assertEqual(a + 0, base) 2656 self.assertEqual((a - 0).__class__, complex) 2657 self.assertEqual(a - 0, base) 2658 self.assertEqual((a * 1).__class__, complex) 2659 self.assertEqual(a * 1, base) 2660 self.assertEqual((a / 1).__class__, complex) 2661 self.assertEqual(a / 1, base) 2662 2663 class madtuple(tuple): 2664 _rev = None 2665 def rev(self): 2666 if self._rev is not None: 2667 return self._rev 2668 L = list(self) 2669 L.reverse() 2670 self._rev = self.__class__(L) 2671 return self._rev 2672 a = madtuple((1,2,3,4,5,6,7,8,9,0)) 2673 self.assertEqual(a, (1,2,3,4,5,6,7,8,9,0)) 2674 self.assertEqual(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1))) 2675 self.assertEqual(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0))) 2676 for i in range(512): 2677 t = madtuple(range(i)) 2678 u = t.rev() 2679 v = u.rev() 2680 self.assertEqual(v, t) 2681 a = madtuple((1,2,3,4,5)) 2682 self.assertEqual(tuple(a), (1,2,3,4,5)) 2683 self.assertIs(tuple(a).__class__, tuple) 2684 self.assertEqual(hash(a), hash((1,2,3,4,5))) 2685 self.assertIs(a[:].__class__, tuple) 2686 self.assertIs((a * 1).__class__, tuple) 2687 self.assertIs((a * 0).__class__, tuple) 2688 self.assertIs((a + ()).__class__, tuple) 2689 a = madtuple(()) 2690 self.assertEqual(tuple(a), ()) 2691 self.assertIs(tuple(a).__class__, tuple) 2692 self.assertIs((a + a).__class__, tuple) 2693 self.assertIs((a * 0).__class__, tuple) 2694 self.assertIs((a * 1).__class__, tuple) 2695 self.assertIs((a * 2).__class__, tuple) 2696 self.assertIs(a[:].__class__, tuple) 2697 2698 class madstring(str): 2699 _rev = None 2700 def rev(self): 2701 if self._rev is not None: 2702 return self._rev 2703 L = list(self) 2704 L.reverse() 2705 self._rev = self.__class__("".join(L)) 2706 return self._rev 2707 s = madstring("abcdefghijklmnopqrstuvwxyz") 2708 self.assertEqual(s, "abcdefghijklmnopqrstuvwxyz") 2709 self.assertEqual(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba")) 2710 self.assertEqual(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz")) 2711 for i in range(256): 2712 s = madstring("".join(map(chr, range(i)))) 2713 t = s.rev() 2714 u = t.rev() 2715 self.assertEqual(u, s) 2716 s = madstring("12345") 2717 self.assertEqual(str(s), "12345") 2718 self.assertIs(str(s).__class__, str) 2719 2720 base = "\x00" * 5 2721 s = madstring(base) 2722 self.assertEqual(s, base) 2723 self.assertEqual(str(s), base) 2724 self.assertIs(str(s).__class__, str) 2725 self.assertEqual(hash(s), hash(base)) 2726 self.assertEqual({s: 1}[base], 1) 2727 self.assertEqual({base: 1}[s], 1) 2728 self.assertIs((s + "").__class__, str) 2729 self.assertEqual(s + "", base) 2730 self.assertIs(("" + s).__class__, str) 2731 self.assertEqual("" + s, base) 2732 self.assertIs((s * 0).__class__, str) 2733 self.assertEqual(s * 0, "") 2734 self.assertIs((s * 1).__class__, str) 2735 self.assertEqual(s * 1, base) 2736 self.assertIs((s * 2).__class__, str) 2737 self.assertEqual(s * 2, base + base) 2738 self.assertIs(s[:].__class__, str) 2739 self.assertEqual(s[:], base) 2740 self.assertIs(s[0:0].__class__, str) 2741 self.assertEqual(s[0:0], "") 2742 self.assertIs(s.strip().__class__, str) 2743 self.assertEqual(s.strip(), base) 2744 self.assertIs(s.lstrip().__class__, str) 2745 self.assertEqual(s.lstrip(), base) 2746 self.assertIs(s.rstrip().__class__, str) 2747 self.assertEqual(s.rstrip(), base) 2748 identitytab = {} 2749 self.assertIs(s.translate(identitytab).__class__, str) 2750 self.assertEqual(s.translate(identitytab), base) 2751 self.assertIs(s.replace("x", "x").__class__, str) 2752 self.assertEqual(s.replace("x", "x"), base) 2753 self.assertIs(s.ljust(len(s)).__class__, str) 2754 self.assertEqual(s.ljust(len(s)), base) 2755 self.assertIs(s.rjust(len(s)).__class__, str) 2756 self.assertEqual(s.rjust(len(s)), base) 2757 self.assertIs(s.center(len(s)).__class__, str) 2758 self.assertEqual(s.center(len(s)), base) 2759 self.assertIs(s.lower().__class__, str) 2760 self.assertEqual(s.lower(), base) 2761 2762 class madunicode(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 u = madunicode("ABCDEF") 2772 self.assertEqual(u, "ABCDEF") 2773 self.assertEqual(u.rev(), madunicode("FEDCBA")) 2774 self.assertEqual(u.rev().rev(), madunicode("ABCDEF")) 2775 base = "12345" 2776 u = madunicode(base) 2777 self.assertEqual(str(u), base) 2778 self.assertIs(str(u).__class__, str) 2779 self.assertEqual(hash(u), hash(base)) 2780 self.assertEqual({u: 1}[base], 1) 2781 self.assertEqual({base: 1}[u], 1) 2782 self.assertIs(u.strip().__class__, str) 2783 self.assertEqual(u.strip(), base) 2784 self.assertIs(u.lstrip().__class__, str) 2785 self.assertEqual(u.lstrip(), base) 2786 self.assertIs(u.rstrip().__class__, str) 2787 self.assertEqual(u.rstrip(), base) 2788 self.assertIs(u.replace("x", "x").__class__, str) 2789 self.assertEqual(u.replace("x", "x"), base) 2790 self.assertIs(u.replace("xy", "xy").__class__, str) 2791 self.assertEqual(u.replace("xy", "xy"), base) 2792 self.assertIs(u.center(len(u)).__class__, str) 2793 self.assertEqual(u.center(len(u)), base) 2794 self.assertIs(u.ljust(len(u)).__class__, str) 2795 self.assertEqual(u.ljust(len(u)), base) 2796 self.assertIs(u.rjust(len(u)).__class__, str) 2797 self.assertEqual(u.rjust(len(u)), base) 2798 self.assertIs(u.lower().__class__, str) 2799 self.assertEqual(u.lower(), base) 2800 self.assertIs(u.upper().__class__, str) 2801 self.assertEqual(u.upper(), base) 2802 self.assertIs(u.capitalize().__class__, str) 2803 self.assertEqual(u.capitalize(), base) 2804 self.assertIs(u.title().__class__, str) 2805 self.assertEqual(u.title(), base) 2806 self.assertIs((u + "").__class__, str) 2807 self.assertEqual(u + "", base) 2808 self.assertIs(("" + u).__class__, str) 2809 self.assertEqual("" + u, base) 2810 self.assertIs((u * 0).__class__, str) 2811 self.assertEqual(u * 0, "") 2812 self.assertIs((u * 1).__class__, str) 2813 self.assertEqual(u * 1, base) 2814 self.assertIs((u * 2).__class__, str) 2815 self.assertEqual(u * 2, base + base) 2816 self.assertIs(u[:].__class__, str) 2817 self.assertEqual(u[:], base) 2818 self.assertIs(u[0:0].__class__, str) 2819 self.assertEqual(u[0:0], "") 2820 2821 class sublist(list): 2822 pass 2823 a = sublist(range(5)) 2824 self.assertEqual(a, list(range(5))) 2825 a.append("hello") 2826 self.assertEqual(a, list(range(5)) + ["hello"]) 2827 a[5] = 5 2828 self.assertEqual(a, list(range(6))) 2829 a.extend(range(6, 20)) 2830 self.assertEqual(a, list(range(20))) 2831 a[-5:] = [] 2832 self.assertEqual(a, list(range(15))) 2833 del a[10:15] 2834 self.assertEqual(len(a), 10) 2835 self.assertEqual(a, list(range(10))) 2836 self.assertEqual(list(a), list(range(10))) 2837 self.assertEqual(a[0], 0) 2838 self.assertEqual(a[9], 9) 2839 self.assertEqual(a[-10], 0) 2840 self.assertEqual(a[-1], 9) 2841 self.assertEqual(a[:5], list(range(5))) 2842 2843 ## class CountedInput(file): 2844 ## """Counts lines read by self.readline(). 2845 ## 2846 ## self.lineno is the 0-based ordinal of the last line read, up to 2847 ## a maximum of one greater than the number of lines in the file. 2848 ## 2849 ## self.ateof is true if and only if the final "" line has been read, 2850 ## at which point self.lineno stops incrementing, and further calls 2851 ## to readline() continue to return "". 2852 ## """ 2853 ## 2854 ## lineno = 0 2855 ## ateof = 0 2856 ## def readline(self): 2857 ## if self.ateof: 2858 ## return "" 2859 ## s = file.readline(self) 2860 ## # Next line works too. 2861 ## # s = super(CountedInput, self).readline() 2862 ## self.lineno += 1 2863 ## if s == "": 2864 ## self.ateof = 1 2865 ## return s 2866 ## 2867 ## f = file(name=support.TESTFN, mode='w') 2868 ## lines = ['a\n', 'b\n', 'c\n'] 2869 ## try: 2870 ## f.writelines(lines) 2871 ## f.close() 2872 ## f = CountedInput(support.TESTFN) 2873 ## for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]): 2874 ## got = f.readline() 2875 ## self.assertEqual(expected, got) 2876 ## self.assertEqual(f.lineno, i) 2877 ## self.assertEqual(f.ateof, (i > len(lines))) 2878 ## f.close() 2879 ## finally: 2880 ## try: 2881 ## f.close() 2882 ## except: 2883 ## pass 2884 ## support.unlink(support.TESTFN) 2885 2886 def test_keywords(self): 2887 # Testing keyword args to basic type constructors ... 2888 self.assertEqual(int(x=1), 1) 2889 self.assertEqual(float(x=2), 2.0) 2890 self.assertEqual(int(x=3), 3) 2891 self.assertEqual(complex(imag=42, real=666), complex(666, 42)) 2892 self.assertEqual(str(object=500), '500') 2893 self.assertEqual(str(object=b'abc', errors='strict'), 'abc') 2894 self.assertEqual(tuple(sequence=range(3)), (0, 1, 2)) 2895 self.assertEqual(list(sequence=(0, 1, 2)), list(range(3))) 2896 # note: as of Python 2.3, dict() no longer has an "items" keyword arg 2897 2898 for constructor in (int, float, int, complex, str, str, 2899 tuple, list): 2900 try: 2901 constructor(bogus_keyword_arg=1) 2902 except TypeError: 2903 pass 2904 else: 2905 self.fail("expected TypeError from bogus keyword argument to %r" 2906 % constructor) 2907 2908 def test_str_subclass_as_dict_key(self): 2909 # Testing a str subclass used as dict key .. 2910 2911 class cistr(str): 2912 """Sublcass of str that computes __eq__ case-insensitively. 2913 2914 Also computes a hash code of the string in canonical form. 2915 """ 2916 2917 def __init__(self, value): 2918 self.canonical = value.lower() 2919 self.hashcode = hash(self.canonical) 2920 2921 def __eq__(self, other): 2922 if not isinstance(other, cistr): 2923 other = cistr(other) 2924 return self.canonical == other.canonical 2925 2926 def __hash__(self): 2927 return self.hashcode 2928 2929 self.assertEqual(cistr('ABC'), 'abc') 2930 self.assertEqual('aBc', cistr('ABC')) 2931 self.assertEqual(str(cistr('ABC')), 'ABC') 2932 2933 d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3} 2934 self.assertEqual(d[cistr('one')], 1) 2935 self.assertEqual(d[cistr('tWo')], 2) 2936 self.assertEqual(d[cistr('THrEE')], 3) 2937 self.assertIn(cistr('ONe'), d) 2938 self.assertEqual(d.get(cistr('thrEE')), 3) 2939 2940 def test_classic_comparisons(self): 2941 # Testing classic comparisons... 2942 class classic: 2943 pass 2944 2945 for base in (classic, int, object): 2946 class C(base): 2947 def __init__(self, value): 2948 self.value = int(value) 2949 def __eq__(self, other): 2950 if isinstance(other, C): 2951 return self.value == other.value 2952 if isinstance(other, int) or isinstance(other, int): 2953 return self.value == other 2954 return NotImplemented 2955 def __ne__(self, other): 2956 if isinstance(other, C): 2957 return self.value != other.value 2958 if isinstance(other, int) or isinstance(other, int): 2959 return self.value != other 2960 return NotImplemented 2961 def __lt__(self, other): 2962 if isinstance(other, C): 2963 return self.value < other.value 2964 if isinstance(other, int) or isinstance(other, int): 2965 return self.value < other 2966 return NotImplemented 2967 def __le__(self, other): 2968 if isinstance(other, C): 2969 return self.value <= other.value 2970 if isinstance(other, int) or isinstance(other, int): 2971 return self.value <= other 2972 return NotImplemented 2973 def __gt__(self, other): 2974 if isinstance(other, C): 2975 return self.value > other.value 2976 if isinstance(other, int) or isinstance(other, int): 2977 return self.value > other 2978 return NotImplemented 2979 def __ge__(self, other): 2980 if isinstance(other, C): 2981 return self.value >= other.value 2982 if isinstance(other, int) or isinstance(other, int): 2983 return self.value >= other 2984 return NotImplemented 2985 2986 c1 = C(1) 2987 c2 = C(2) 2988 c3 = C(3) 2989 self.assertEqual(c1, 1) 2990 c = {1: c1, 2: c2, 3: c3} 2991 for x in 1, 2, 3: 2992 for y in 1, 2, 3: 2993 for op in "<", "<=", "==", "!=", ">", ">=": 2994 self.assertEqual(eval("c[x] %s c[y]" % op), 2995 eval("x %s y" % op), 2996 "x=%d, y=%d" % (x, y)) 2997 self.assertEqual(eval("c[x] %s y" % op), 2998 eval("x %s y" % op), 2999 "x=%d, y=%d" % (x, y)) 3000 self.assertEqual(eval("x %s c[y]" % op), 3001 eval("x %s y" % op), 3002 "x=%d, y=%d" % (x, y)) 3003 3004 def test_rich_comparisons(self): 3005 # Testing rich comparisons... 3006 class Z(complex): 3007 pass 3008 z = Z(1) 3009 self.assertEqual(z, 1+0j) 3010 self.assertEqual(1+0j, z) 3011 class ZZ(complex): 3012 def __eq__(self, other): 3013 try: 3014 return abs(self - other) <= 1e-6 3015 except: 3016 return NotImplemented 3017 zz = ZZ(1.0000003) 3018 self.assertEqual(zz, 1+0j) 3019 self.assertEqual(1+0j, zz) 3020 3021 class classic: 3022 pass 3023 for base in (classic, int, object, list): 3024 class C(base): 3025 def __init__(self, value): 3026 self.value = int(value) 3027 def __cmp__(self_, other): 3028 self.fail("shouldn't call __cmp__") 3029 def __eq__(self, other): 3030 if isinstance(other, C): 3031 return self.value == other.value 3032 if isinstance(other, int) or isinstance(other, int): 3033 return self.value == other 3034 return NotImplemented 3035 def __ne__(self, other): 3036 if isinstance(other, C): 3037 return self.value != other.value 3038 if isinstance(other, int) or isinstance(other, int): 3039 return self.value != other 3040 return NotImplemented 3041 def __lt__(self, other): 3042 if isinstance(other, C): 3043 return self.value < other.value 3044 if isinstance(other, int) or isinstance(other, int): 3045 return self.value < other 3046 return NotImplemented 3047 def __le__(self, other): 3048 if isinstance(other, C): 3049 return self.value <= other.value 3050 if isinstance(other, int) or isinstance(other, int): 3051 return self.value <= other 3052 return NotImplemented 3053 def __gt__(self, other): 3054 if isinstance(other, C): 3055 return self.value > other.value 3056 if isinstance(other, int) or isinstance(other, int): 3057 return self.value > other 3058 return NotImplemented 3059 def __ge__(self, other): 3060 if isinstance(other, C): 3061 return self.value >= other.value 3062 if isinstance(other, int) or isinstance(other, int): 3063 return self.value >= other 3064 return NotImplemented 3065 c1 = C(1) 3066 c2 = C(2) 3067 c3 = C(3) 3068 self.assertEqual(c1, 1) 3069 c = {1: c1, 2: c2, 3: c3} 3070 for x in 1, 2, 3: 3071 for y in 1, 2, 3: 3072 for op in "<", "<=", "==", "!=", ">", ">=": 3073 self.assertEqual(eval("c[x] %s c[y]" % op), 3074 eval("x %s y" % op), 3075 "x=%d, y=%d" % (x, y)) 3076 self.assertEqual(eval("c[x] %s y" % op), 3077 eval("x %s y" % op), 3078 "x=%d, y=%d" % (x, y)) 3079 self.assertEqual(eval("x %s c[y]" % op), 3080 eval("x %s y" % op), 3081 "x=%d, y=%d" % (x, y)) 3082 3083 def test_descrdoc(self): 3084 # Testing descriptor doc strings... 3085 from _io import FileIO 3086 def check(descr, what): 3087 self.assertEqual(descr.__doc__, what) 3088 check(FileIO.closed, "True if the file is closed") # getset descriptor 3089 check(complex.real, "the real part of a complex number") # member descriptor 3090 3091 def test_doc_descriptor(self): 3092 # Testing __doc__ descriptor... 3093 # SF bug 542984 3094 class DocDescr(object): 3095 def __get__(self, object, otype): 3096 if object: 3097 object = object.__class__.__name__ + ' instance' 3098 if otype: 3099 otype = otype.__name__ 3100 return 'object=%s; type=%s' % (object, otype) 3101 class OldClass: 3102 __doc__ = DocDescr() 3103 class NewClass(object): 3104 __doc__ = DocDescr() 3105 self.assertEqual(OldClass.__doc__, 'object=None; type=OldClass') 3106 self.assertEqual(OldClass().__doc__, 'object=OldClass instance; type=OldClass') 3107 self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass') 3108 self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass') 3109 3110 def test_set_class(self): 3111 # Testing __class__ assignment... 3112 class C(object): pass 3113 class D(object): pass 3114 class E(object): pass 3115 class F(D, E): pass 3116 for cls in C, D, E, F: 3117 for cls2 in C, D, E, F: 3118 x = cls() 3119 x.__class__ = cls2 3120 self.assertIs(x.__class__, cls2) 3121 x.__class__ = cls 3122 self.assertIs(x.__class__, cls) 3123 def cant(x, C): 3124 try: 3125 x.__class__ = C 3126 except TypeError: 3127 pass 3128 else: 3129 self.fail("shouldn't allow %r.__class__ = %r" % (x, C)) 3130 try: 3131 delattr(x, "__class__") 3132 except (TypeError, AttributeError): 3133 pass 3134 else: 3135 self.fail("shouldn't allow del %r.__class__" % x) 3136 cant(C(), list) 3137 cant(list(), C) 3138 cant(C(), 1) 3139 cant(C(), object) 3140 cant(object(), list) 3141 cant(list(), object) 3142 class Int(int): __slots__ = [] 3143 cant(True, int) 3144 cant(2, bool) 3145 o = object() 3146 cant(o, type(1)) 3147 cant(o, type(None)) 3148 del o 3149 class G(object): 3150 __slots__ = ["a", "b"] 3151 class H(object): 3152 __slots__ = ["b", "a"] 3153 class I(object): 3154 __slots__ = ["a", "b"] 3155 class J(object): 3156 __slots__ = ["c", "b"] 3157 class K(object): 3158 __slots__ = ["a", "b", "d"] 3159 class L(H): 3160 __slots__ = ["e"] 3161 class M(I): 3162 __slots__ = ["e"] 3163 class N(J): 3164 __slots__ = ["__weakref__"] 3165 class P(J): 3166 __slots__ = ["__dict__"] 3167 class Q(J): 3168 pass 3169 class R(J): 3170 __slots__ = ["__dict__", "__weakref__"] 3171 3172 for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)): 3173 x = cls() 3174 x.a = 1 3175 x.__class__ = cls2 3176 self.assertIs(x.__class__, cls2, 3177 "assigning %r as __class__ for %r silently failed" % (cls2, x)) 3178 self.assertEqual(x.a, 1) 3179 x.__class__ = cls 3180 self.assertIs(x.__class__, cls, 3181 "assigning %r as __class__ for %r silently failed" % (cls, x)) 3182 self.assertEqual(x.a, 1) 3183 for cls in G, J, K, L, M, N, P, R, list, Int: 3184 for cls2 in G, J, K, L, M, N, P, R, list, Int: 3185 if cls is cls2: 3186 continue 3187 cant(cls(), cls2) 3188 3189 # Issue5283: when __class__ changes in __del__, the wrong 3190 # type gets DECREF'd. 3191 class O(object): 3192 pass 3193 class A(object): 3194 def __del__(self): 3195 self.__class__ = O 3196 l = [A() for x in range(100)] 3197 del l 3198 3199 def test_set_dict(self): 3200 # Testing __dict__ assignment... 3201 class C(object): pass 3202 a = C() 3203 a.__dict__ = {'b': 1} 3204 self.assertEqual(a.b, 1) 3205 def cant(x, dict): 3206 try: 3207 x.__dict__ = dict 3208 except (AttributeError, TypeError): 3209 pass 3210 else: 3211 self.fail("shouldn't allow %r.__dict__ = %r" % (x, dict)) 3212 cant(a, None) 3213 cant(a, []) 3214 cant(a, 1) 3215 del a.__dict__ # Deleting __dict__ is allowed 3216 3217 class Base(object): 3218 pass 3219 def verify_dict_readonly(x): 3220 """ 3221 x has to be an instance of a class inheriting from Base. 3222 """ 3223 cant(x, {}) 3224 try: 3225 del x.__dict__ 3226 except (AttributeError, TypeError): 3227 pass 3228 else: 3229 self.fail("shouldn't allow del %r.__dict__" % x) 3230 dict_descr = Base.__dict__["__dict__"] 3231 try: 3232 dict_descr.__set__(x, {}) 3233 except (AttributeError, TypeError): 3234 pass 3235 else: 3236 self.fail("dict_descr allowed access to %r's dict" % x) 3237 3238 # Classes don't allow __dict__ assignment and have readonly dicts 3239 class Meta1(type, Base): 3240 pass 3241 class Meta2(Base, type): 3242 pass 3243 class D(object, metaclass=Meta1): 3244 pass 3245 class E(object, metaclass=Meta2): 3246 pass 3247 for cls in C, D, E: 3248 verify_dict_readonly(cls) 3249 class_dict = cls.__dict__ 3250 try: 3251 class_dict["spam"] = "eggs" 3252 except TypeError: 3253 pass 3254 else: 3255 self.fail("%r's __dict__ can be modified" % cls) 3256 3257 # Modules also disallow __dict__ assignment 3258 class Module1(types.ModuleType, Base): 3259 pass 3260 class Module2(Base, types.ModuleType): 3261 pass 3262 for ModuleType in Module1, Module2: 3263 mod = ModuleType("spam") 3264 verify_dict_readonly(mod) 3265 mod.__dict__["spam"] = "eggs" 3266 3267 # Exception's __dict__ can be replaced, but not deleted 3268 # (at least not any more than regular exception's __dict__ can 3269 # be deleted; on CPython it is not the case, whereas on PyPy they 3270 # can, just like any other new-style instance's __dict__.) 3271 def can_delete_dict(e): 3272 try: 3273 del e.__dict__ 3274 except (TypeError, AttributeError): 3275 return False 3276 else: 3277 return True 3278 class Exception1(Exception, Base): 3279 pass 3280 class Exception2(Base, Exception): 3281 pass 3282 for ExceptionType in Exception, Exception1, Exception2: 3283 e = ExceptionType() 3284 e.__dict__ = {"a": 1} 3285 self.assertEqual(e.a, 1) 3286 self.assertEqual(can_delete_dict(e), can_delete_dict(ValueError())) 3287 3288 def test_binary_operator_override(self): 3289 # Testing overrides of binary operations... 3290 class I(int): 3291 def __repr__(self): 3292 return "I(%r)" % int(self) 3293 def __add__(self, other): 3294 return I(int(self) + int(other)) 3295 __radd__ = __add__ 3296 def __pow__(self, other, mod=None): 3297 if mod is None: 3298 return I(pow(int(self), int(other))) 3299 else: 3300 return I(pow(int(self), int(other), int(mod))) 3301 def __rpow__(self, other, mod=None): 3302 if mod is None: 3303 return I(pow(int(other), int(self), mod)) 3304 else: 3305 return I(pow(int(other), int(self), int(mod))) 3306 3307 self.assertEqual(repr(I(1) + I(2)), "I(3)") 3308 self.assertEqual(repr(I(1) + 2), "I(3)") 3309 self.assertEqual(repr(1 + I(2)), "I(3)") 3310 self.assertEqual(repr(I(2) ** I(3)), "I(8)") 3311 self.assertEqual(repr(2 ** I(3)), "I(8)") 3312 self.assertEqual(repr(I(2) ** 3), "I(8)") 3313 self.assertEqual(repr(pow(I(2), I(3), I(5))), "I(3)") 3314 class S(str): 3315 def __eq__(self, other): 3316 return self.lower() == other.lower() 3317 3318 def test_subclass_propagation(self): 3319 # Testing propagation of slot functions to subclasses... 3320 class A(object): 3321 pass 3322 class B(A): 3323 pass 3324 class C(A): 3325 pass 3326 class D(B, C): 3327 pass 3328 d = D() 3329 orig_hash = hash(d) # related to id(d) in platform-dependent ways 3330 A.__hash__ = lambda self: 42 3331 self.assertEqual(hash(d), 42) 3332 C.__hash__ = lambda self: 314 3333 self.assertEqual(hash(d), 314) 3334 B.__hash__ = lambda self: 144 3335 self.assertEqual(hash(d), 144) 3336 D.__hash__ = lambda self: 100 3337 self.assertEqual(hash(d), 100) 3338 D.__hash__ = None 3339 self.assertRaises(TypeError, hash, d) 3340 del D.__hash__ 3341 self.assertEqual(hash(d), 144) 3342 B.__hash__ = None 3343 self.assertRaises(TypeError, hash, d) 3344 del B.__hash__ 3345 self.assertEqual(hash(d), 314) 3346 C.__hash__ = None 3347 self.assertRaises(TypeError, hash, d) 3348 del C.__hash__ 3349 self.assertEqual(hash(d), 42) 3350 A.__hash__ = None 3351 self.assertRaises(TypeError, hash, d) 3352 del A.__hash__ 3353 self.assertEqual(hash(d), orig_hash) 3354 d.foo = 42 3355 d.bar = 42 3356 self.assertEqual(d.foo, 42) 3357 self.assertEqual(d.bar, 42) 3358 def __getattribute__(self, name): 3359 if name == "foo": 3360 return 24 3361 return object.__getattribute__(self, name) 3362 A.__getattribute__ = __getattribute__ 3363 self.assertEqual(d.foo, 24) 3364 self.assertEqual(d.bar, 42) 3365 def __getattr__(self, name): 3366 if name in ("spam", "foo", "bar"): 3367 return "hello" 3368 raise AttributeError(name) 3369 B.__getattr__ = __getattr__ 3370 self.assertEqual(d.spam, "hello") 3371 self.assertEqual(d.foo, 24) 3372 self.assertEqual(d.bar, 42) 3373 del A.__getattribute__ 3374 self.assertEqual(d.foo, 42) 3375 del d.foo 3376 self.assertEqual(d.foo, "hello") 3377 self.assertEqual(d.bar, 42) 3378 del B.__getattr__ 3379 try: 3380 d.foo 3381 except AttributeError: 3382 pass 3383 else: 3384 self.fail("d.foo should be undefined now") 3385 3386 # Test a nasty bug in recurse_down_subclasses() 3387 class A(object): 3388 pass 3389 class B(A): 3390 pass 3391 del B 3392 support.gc_collect() 3393 A.__setitem__ = lambda *a: None # crash 3394 3395 def test_buffer_inheritance(self): 3396 # Testing that buffer interface is inherited ... 3397 3398 import binascii 3399 # SF bug [#470040] ParseTuple t# vs subclasses. 3400 3401 class MyBytes(bytes): 3402 pass 3403 base = b'abc' 3404 m = MyBytes(base) 3405 # b2a_hex uses the buffer interface to get its argument's value, via 3406 # PyArg_ParseTuple 't#' code. 3407 self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base)) 3408 3409 class MyInt(int): 3410 pass 3411 m = MyInt(42) 3412 try: 3413 binascii.b2a_hex(m) 3414 self.fail('subclass of int should not have a buffer interface') 3415 except TypeError: 3416 pass 3417 3418 def test_str_of_str_subclass(self): 3419 # Testing __str__ defined in subclass of str ... 3420 import binascii 3421 import io 3422 3423 class octetstring(str): 3424 def __str__(self): 3425 return binascii.b2a_hex(self.encode('ascii')).decode("ascii") 3426 def __repr__(self): 3427 return self + " repr" 3428 3429 o = octetstring('A') 3430 self.assertEqual(type(o), octetstring) 3431 self.assertEqual(type(str(o)), str) 3432 self.assertEqual(type(repr(o)), str) 3433 self.assertEqual(ord(o), 0x41) 3434 self.assertEqual(str(o), '41') 3435 self.assertEqual(repr(o), 'A repr') 3436 self.assertEqual(o.__str__(), '41') 3437 self.assertEqual(o.__repr__(), 'A repr') 3438 3439 capture = io.StringIO() 3440 # Calling str() or not exercises different internal paths. 3441 print(o, file=capture) 3442 print(str(o), file=capture) 3443 self.assertEqual(capture.getvalue(), '41\n41\n') 3444 capture.close() 3445 3446 def test_keyword_arguments(self): 3447 # Testing keyword arguments to __init__, __call__... 3448 def f(a): return a 3449 self.assertEqual(f.__call__(a=42), 42) 3450 a = [] 3451 list.__init__(a, sequence=[0, 1, 2]) 3452 self.assertEqual(a, [0, 1, 2]) 3453 3454 def test_recursive_call(self): 3455 # Testing recursive __call__() by setting to instance of class... 3456 class A(object): 3457 pass 3458 3459 A.__call__ = A() 3460 try: 3461 A()() 3462 except RecursionError: 3463 pass 3464 else: 3465 self.fail("Recursion limit should have been reached for __call__()") 3466 3467 def test_delete_hook(self): 3468 # Testing __del__ hook... 3469 log = [] 3470 class C(object): 3471 def __del__(self): 3472 log.append(1) 3473 c = C() 3474 self.assertEqual(log, []) 3475 del c 3476 support.gc_collect() 3477 self.assertEqual(log, [1]) 3478 3479 class D(object): pass 3480 d = D() 3481 try: del d[0] 3482 except TypeError: pass 3483 else: self.fail("invalid del() didn't raise TypeError") 3484 3485 def test_hash_inheritance(self): 3486 # Testing hash of mutable subclasses... 3487 3488 class mydict(dict): 3489 pass 3490 d = mydict() 3491 try: 3492 hash(d) 3493 except TypeError: 3494 pass 3495 else: 3496 self.fail("hash() of dict subclass should fail") 3497 3498 class mylist(list): 3499 pass 3500 d = mylist() 3501 try: 3502 hash(d) 3503 except TypeError: 3504 pass 3505 else: 3506 self.fail("hash() of list subclass should fail") 3507 3508 def test_str_operations(self): 3509 try: 'a' + 5 3510 except TypeError: pass 3511 else: self.fail("'' + 5 doesn't raise TypeError") 3512 3513 try: ''.split('') 3514 except ValueError: pass 3515 else: self.fail("''.split('') doesn't raise ValueError") 3516 3517 try: ''.join([0]) 3518 except TypeError: pass 3519 else: self.fail("''.join([0]) doesn't raise TypeError") 3520 3521 try: ''.rindex('5') 3522 except ValueError: pass 3523 else: self.fail("''.rindex('5') doesn't raise ValueError") 3524 3525 try: '%(n)s' % None 3526 except TypeError: pass 3527 else: self.fail("'%(n)s' % None doesn't raise TypeError") 3528 3529 try: '%(n' % {} 3530 except ValueError: pass 3531 else: self.fail("'%(n' % {} '' doesn't raise ValueError") 3532 3533 try: '%*s' % ('abc') 3534 except TypeError: pass 3535 else: self.fail("'%*s' % ('abc') doesn't raise TypeError") 3536 3537 try: '%*.*s' % ('abc', 5) 3538 except TypeError: pass 3539 else: self.fail("'%*.*s' % ('abc', 5) doesn't raise TypeError") 3540 3541 try: '%s' % (1, 2) 3542 except TypeError: pass 3543 else: self.fail("'%s' % (1, 2) doesn't raise TypeError") 3544 3545 try: '%' % None 3546 except ValueError: pass 3547 else: self.fail("'%' % None doesn't raise ValueError") 3548 3549 self.assertEqual('534253'.isdigit(), 1) 3550 self.assertEqual('534253x'.isdigit(), 0) 3551 self.assertEqual('%c' % 5, '\x05') 3552 self.assertEqual('%c' % '5', '5') 3553 3554 def test_deepcopy_recursive(self): 3555 # Testing deepcopy of recursive objects... 3556 class Node: 3557 pass 3558 a = Node() 3559 b = Node() 3560 a.b = b 3561 b.a = a 3562 z = deepcopy(a) # This blew up before 3563 3564 def test_uninitialized_modules(self): 3565 # Testing uninitialized module objects... 3566 from types import ModuleType as M 3567 m = M.__new__(M) 3568 str(m) 3569 self.assertNotHasAttr(m, "__name__") 3570 self.assertNotHasAttr(m, "__file__") 3571 self.assertNotHasAttr(m, "foo") 3572 self.assertFalse(m.__dict__) # None or {} are both reasonable answers 3573 m.foo = 1 3574 self.assertEqual(m.__dict__, {"foo": 1}) 3575 3576 def test_funny_new(self): 3577 # Testing __new__ returning something unexpected... 3578 class C(object): 3579 def __new__(cls, arg): 3580 if isinstance(arg, str): return [1, 2, 3] 3581 elif isinstance(arg, int): return object.__new__(D) 3582 else: return object.__new__(cls) 3583 class D(C): 3584 def __init__(self, arg): 3585 self.foo = arg 3586 self.assertEqual(C("1"), [1, 2, 3]) 3587 self.assertEqual(D("1"), [1, 2, 3]) 3588 d = D(None) 3589 self.assertEqual(d.foo, None) 3590 d = C(1) 3591 self.assertIsInstance(d, D) 3592 self.assertEqual(d.foo, 1) 3593 d = D(1) 3594 self.assertIsInstance(d, D) 3595 self.assertEqual(d.foo, 1) 3596 3597 class C(object): 3598 @staticmethod 3599 def __new__(*args): 3600 return args 3601 self.assertEqual(C(1, 2), (C, 1, 2)) 3602 class D(C): 3603 pass 3604 self.assertEqual(D(1, 2), (D, 1, 2)) 3605 3606 class C(object): 3607 @classmethod 3608 def __new__(*args): 3609 return args 3610 self.assertEqual(C(1, 2), (C, C, 1, 2)) 3611 class D(C): 3612 pass 3613 self.assertEqual(D(1, 2), (D, D, 1, 2)) 3614 3615 def test_imul_bug(self): 3616 # Testing for __imul__ problems... 3617 # SF bug 544647 3618 class C(object): 3619 def __imul__(self, other): 3620 return (self, other) 3621 x = C() 3622 y = x 3623 y *= 1.0 3624 self.assertEqual(y, (x, 1.0)) 3625 y = x 3626 y *= 2 3627 self.assertEqual(y, (x, 2)) 3628 y = x 3629 y *= 3 3630 self.assertEqual(y, (x, 3)) 3631 y = x 3632 y *= 1<<100 3633 self.assertEqual(y, (x, 1<<100)) 3634 y = x 3635 y *= None 3636 self.assertEqual(y, (x, None)) 3637 y = x 3638 y *= "foo" 3639 self.assertEqual(y, (x, "foo")) 3640 3641 def test_copy_setstate(self): 3642 # Testing that copy.*copy() correctly uses __setstate__... 3643 import copy 3644 class C(object): 3645 def __init__(self, foo=None): 3646 self.foo = foo 3647 self.__foo = foo 3648 def setfoo(self, foo=None): 3649 self.foo = foo 3650 def getfoo(self): 3651 return self.__foo 3652 def __getstate__(self): 3653 return [self.foo] 3654 def __setstate__(self_, lst): 3655 self.assertEqual(len(lst), 1) 3656 self_.__foo = self_.foo = lst[0] 3657 a = C(42) 3658 a.setfoo(24) 3659 self.assertEqual(a.foo, 24) 3660 self.assertEqual(a.getfoo(), 42) 3661 b = copy.copy(a) 3662 self.assertEqual(b.foo, 24) 3663 self.assertEqual(b.getfoo(), 24) 3664 b = copy.deepcopy(a) 3665 self.assertEqual(b.foo, 24) 3666 self.assertEqual(b.getfoo(), 24) 3667 3668 def test_slices(self): 3669 # Testing cases with slices and overridden __getitem__ ... 3670 3671 # Strings 3672 self.assertEqual("hello"[:4], "hell") 3673 self.assertEqual("hello"[slice(4)], "hell") 3674 self.assertEqual(str.__getitem__("hello", slice(4)), "hell") 3675 class S(str): 3676 def __getitem__(self, x): 3677 return str.__getitem__(self, x) 3678 self.assertEqual(S("hello")[:4], "hell") 3679 self.assertEqual(S("hello")[slice(4)], "hell") 3680 self.assertEqual(S("hello").__getitem__(slice(4)), "hell") 3681 # Tuples 3682 self.assertEqual((1,2,3)[:2], (1,2)) 3683 self.assertEqual((1,2,3)[slice(2)], (1,2)) 3684 self.assertEqual(tuple.__getitem__((1,2,3), slice(2)), (1,2)) 3685 class T(tuple): 3686 def __getitem__(self, x): 3687 return tuple.__getitem__(self, x) 3688 self.assertEqual(T((1,2,3))[:2], (1,2)) 3689 self.assertEqual(T((1,2,3))[slice(2)], (1,2)) 3690 self.assertEqual(T((1,2,3)).__getitem__(slice(2)), (1,2)) 3691 # Lists 3692 self.assertEqual([1,2,3][:2], [1,2]) 3693 self.assertEqual([1,2,3][slice(2)], [1,2]) 3694 self.assertEqual(list.__getitem__([1,2,3], slice(2)), [1,2]) 3695 class L(list): 3696 def __getitem__(self, x): 3697 return list.__getitem__(self, x) 3698 self.assertEqual(L([1,2,3])[:2], [1,2]) 3699 self.assertEqual(L([1,2,3])[slice(2)], [1,2]) 3700 self.assertEqual(L([1,2,3]).__getitem__(slice(2)), [1,2]) 3701 # Now do lists and __setitem__ 3702 a = L([1,2,3]) 3703 a[slice(1, 3)] = [3,2] 3704 self.assertEqual(a, [1,3,2]) 3705 a[slice(0, 2, 1)] = [3,1] 3706 self.assertEqual(a, [3,1,2]) 3707 a.__setitem__(slice(1, 3), [2,1]) 3708 self.assertEqual(a, [3,2,1]) 3709 a.__setitem__(slice(0, 2, 1), [2,3]) 3710 self.assertEqual(a, [2,3,1]) 3711 3712 def test_subtype_resurrection(self): 3713 # Testing resurrection of new-style instance... 3714 3715 class C(object): 3716 container = [] 3717 3718 def __del__(self): 3719 # resurrect the instance 3720 C.container.append(self) 3721 3722 c = C() 3723 c.attr = 42 3724 3725 # The most interesting thing here is whether this blows up, due to 3726 # flawed GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1 3727 # bug). 3728 del c 3729 3730 support.gc_collect() 3731 self.assertEqual(len(C.container), 1) 3732 3733 # Make c mortal again, so that the test framework with -l doesn't report 3734 # it as a leak. 3735 del C.__del__ 3736 3737 def test_slots_trash(self): 3738 # Testing slot trash... 3739 # Deallocating deeply nested slotted trash caused stack overflows 3740 class trash(object): 3741 __slots__ = ['x'] 3742 def __init__(self, x): 3743 self.x = x 3744 o = None 3745 for i in range(50000): 3746 o = trash(o) 3747 del o 3748 3749 def test_slots_multiple_inheritance(self): 3750 # SF bug 575229, multiple inheritance w/ slots dumps core 3751 class A(object): 3752 __slots__=() 3753 class B(object): 3754 pass 3755 class C(A,B) : 3756 __slots__=() 3757 if support.check_impl_detail(): 3758 self.assertEqual(C.__basicsize__, B.__basicsize__) 3759 self.assertHasAttr(C, '__dict__') 3760 self.assertHasAttr(C, '__weakref__') 3761 C().x = 2 3762 3763 def test_rmul(self): 3764 # Testing correct invocation of __rmul__... 3765 # SF patch 592646 3766 class C(object): 3767 def __mul__(self, other): 3768 return "mul" 3769 def __rmul__(self, other): 3770 return "rmul" 3771 a = C() 3772 self.assertEqual(a*2, "mul") 3773 self.assertEqual(a*2.2, "mul") 3774 self.assertEqual(2*a, "rmul") 3775 self.assertEqual(2.2*a, "rmul") 3776 3777 def test_ipow(self): 3778 # Testing correct invocation of __ipow__... 3779 # [SF bug 620179] 3780 class C(object): 3781 def __ipow__(self, other): 3782 pass 3783 a = C() 3784 a **= 2 3785 3786 def test_mutable_bases(self): 3787 # Testing mutable bases... 3788 3789 # stuff that should work: 3790 class C(object): 3791 pass 3792 class C2(object): 3793 def __getattribute__(self, attr): 3794 if attr == 'a': 3795 return 2 3796 else: 3797 return super(C2, self).__getattribute__(attr) 3798 def meth(self): 3799 return 1 3800 class D(C): 3801 pass 3802 class E(D): 3803 pass 3804 d = D() 3805 e = E() 3806 D.__bases__ = (C,) 3807 D.__bases__ = (C2,) 3808 self.assertEqual(d.meth(), 1) 3809 self.assertEqual(e.meth(), 1) 3810 self.assertEqual(d.a, 2) 3811 self.assertEqual(e.a, 2) 3812 self.assertEqual(C2.__subclasses__(), [D]) 3813 3814 try: 3815 del D.__bases__ 3816 except (TypeError, AttributeError): 3817 pass 3818 else: 3819 self.fail("shouldn't be able to delete .__bases__") 3820 3821 try: 3822 D.__bases__ = () 3823 except TypeError as msg: 3824 if str(msg) == "a new-style class can't have only classic bases": 3825 self.fail("wrong error message for .__bases__ = ()") 3826 else: 3827 self.fail("shouldn't be able to set .__bases__ to ()") 3828 3829 try: 3830 D.__bases__ = (D,) 3831 except TypeError: 3832 pass 3833 else: 3834 # actually, we'll have crashed by here... 3835 self.fail("shouldn't be able to create inheritance cycles") 3836 3837 try: 3838 D.__bases__ = (C, C) 3839 except TypeError: 3840 pass 3841 else: 3842 self.fail("didn't detect repeated base classes") 3843 3844 try: 3845 D.__bases__ = (E,) 3846 except TypeError: 3847 pass 3848 else: 3849 self.fail("shouldn't be able to create inheritance cycles") 3850 3851 def test_builtin_bases(self): 3852 # Make sure all the builtin types can have their base queried without 3853 # segfaulting. See issue #5787. 3854 builtin_types = [tp for tp in builtins.__dict__.values() 3855 if isinstance(tp, type)] 3856 for tp in builtin_types: 3857 object.__getattribute__(tp, "__bases__") 3858 if tp is not object: 3859 self.assertEqual(len(tp.__bases__), 1, tp) 3860 3861 class L(list): 3862 pass 3863 3864 class C(object): 3865 pass 3866 3867 class D(C): 3868 pass 3869 3870 try: 3871 L.__bases__ = (dict,) 3872 except TypeError: 3873 pass 3874 else: 3875 self.fail("shouldn't turn list subclass into dict subclass") 3876 3877 try: 3878 list.__bases__ = (dict,) 3879 except TypeError: 3880 pass 3881 else: 3882 self.fail("shouldn't be able to assign to list.__bases__") 3883 3884 try: 3885 D.__bases__ = (C, list) 3886 except TypeError: 3887 pass 3888 else: 3889 assert 0, "best_base calculation found wanting" 3890 3891 def test_unsubclassable_types(self): 3892 with self.assertRaises(TypeError): 3893 class X(type(None)): 3894 pass 3895 with self.assertRaises(TypeError): 3896 class X(object, type(None)): 3897 pass 3898 with self.assertRaises(TypeError): 3899 class X(type(None), object): 3900 pass 3901 class O(object): 3902 pass 3903 with self.assertRaises(TypeError): 3904 class X(O, type(None)): 3905 pass 3906 with self.assertRaises(TypeError): 3907 class X(type(None), O): 3908 pass 3909 3910 class X(object): 3911 pass 3912 with self.assertRaises(TypeError): 3913 X.__bases__ = type(None), 3914 with self.assertRaises(TypeError): 3915 X.__bases__ = object, type(None) 3916 with self.assertRaises(TypeError): 3917 X.__bases__ = type(None), object 3918 with self.assertRaises(TypeError): 3919 X.__bases__ = O, type(None) 3920 with self.assertRaises(TypeError): 3921 X.__bases__ = type(None), O 3922 3923 def test_mutable_bases_with_failing_mro(self): 3924 # Testing mutable bases with failing mro... 3925 class WorkOnce(type): 3926 def __new__(self, name, bases, ns): 3927 self.flag = 0 3928 return super(WorkOnce, self).__new__(WorkOnce, name, bases, ns) 3929 def mro(self): 3930 if self.flag > 0: 3931 raise RuntimeError("bozo") 3932 else: 3933 self.flag += 1 3934 return type.mro(self) 3935 3936 class WorkAlways(type): 3937 def mro(self): 3938 # this is here to make sure that .mro()s aren't called 3939 # with an exception set (which was possible at one point). 3940 # An error message will be printed in a debug build. 3941 # What's a good way to test for this? 3942 return type.mro(self) 3943 3944 class C(object): 3945 pass 3946 3947 class C2(object): 3948 pass 3949 3950 class D(C): 3951 pass 3952 3953 class E(D): 3954 pass 3955 3956 class F(D, metaclass=WorkOnce): 3957 pass 3958 3959 class G(D, metaclass=WorkAlways): 3960 pass 3961 3962 # Immediate subclasses have their mro's adjusted in alphabetical 3963 # order, so E's will get adjusted before adjusting F's fails. We 3964 # check here that E's gets restored. 3965 3966 E_mro_before = E.__mro__ 3967 D_mro_before = D.__mro__ 3968 3969 try: 3970 D.__bases__ = (C2,) 3971 except RuntimeError: 3972 self.assertEqual(E.__mro__, E_mro_before) 3973 self.assertEqual(D.__mro__, D_mro_before) 3974 else: 3975 self.fail("exception not propagated") 3976 3977 def test_mutable_bases_catch_mro_conflict(self): 3978 # Testing mutable bases catch mro conflict... 3979 class A(object): 3980 pass 3981 3982 class B(object): 3983 pass 3984 3985 class C(A, B): 3986 pass 3987 3988 class D(A, B): 3989 pass 3990 3991 class E(C, D): 3992 pass 3993 3994 try: 3995 C.__bases__ = (B, A) 3996 except TypeError: 3997 pass 3998 else: 3999 self.fail("didn't catch MRO conflict") 4000 4001 def test_mutable_names(self): 4002 # Testing mutable names... 4003 class C(object): 4004 pass 4005 4006 # C.__module__ could be 'test_descr' or '__main__' 4007 mod = C.__module__ 4008 4009 C.__name__ = 'D' 4010 self.assertEqual((C.__module__, C.__name__), (mod, 'D')) 4011 4012 C.__name__ = 'D.E' 4013 self.assertEqual((C.__module__, C.__name__), (mod, 'D.E')) 4014 4015 def test_evil_type_name(self): 4016 # A badly placed Py_DECREF in type_set_name led to arbitrary code 4017 # execution while the type structure was not in a sane state, and a 4018 # possible segmentation fault as a result. See bug #16447. 4019 class Nasty(str): 4020 def __del__(self): 4021 C.__name__ = "other" 4022 4023 class C: 4024 pass 4025 4026 C.__name__ = Nasty("abc") 4027 C.__name__ = "normal" 4028 4029 def test_subclass_right_op(self): 4030 # Testing correct dispatch of subclass overloading __r<op>__... 4031 4032 # This code tests various cases where right-dispatch of a subclass 4033 # should be preferred over left-dispatch of a base class. 4034 4035 # Case 1: subclass of int; this tests code in abstract.c::binary_op1() 4036 4037 class B(int): 4038 def __floordiv__(self, other): 4039 return "B.__floordiv__" 4040 def __rfloordiv__(self, other): 4041 return "B.__rfloordiv__" 4042 4043 self.assertEqual(B(1) // 1, "B.__floordiv__") 4044 self.assertEqual(1 // B(1), "B.__rfloordiv__") 4045 4046 # Case 2: subclass of object; this is just the baseline for case 3 4047 4048 class C(object): 4049 def __floordiv__(self, other): 4050 return "C.__floordiv__" 4051 def __rfloordiv__(self, other): 4052 return "C.__rfloordiv__" 4053 4054 self.assertEqual(C() // 1, "C.__floordiv__") 4055 self.assertEqual(1 // C(), "C.__rfloordiv__") 4056 4057 # Case 3: subclass of new-style class; here it gets interesting 4058 4059 class D(C): 4060 def __floordiv__(self, other): 4061 return "D.__floordiv__" 4062 def __rfloordiv__(self, other): 4063 return "D.__rfloordiv__" 4064 4065 self.assertEqual(D() // C(), "D.__floordiv__") 4066 self.assertEqual(C() // D(), "D.__rfloordiv__") 4067 4068 # Case 4: this didn't work right in 2.2.2 and 2.3a1 4069 4070 class E(C): 4071 pass 4072 4073 self.assertEqual(E.__rfloordiv__, C.__rfloordiv__) 4074 4075 self.assertEqual(E() // 1, "C.__floordiv__") 4076 self.assertEqual(1 // E(), "C.__rfloordiv__") 4077 self.assertEqual(E() // C(), "C.__floordiv__") 4078 self.assertEqual(C() // E(), "C.__floordiv__") # This one would fail 4079 4080 @support.impl_detail("testing an internal kind of method object") 4081 def test_meth_class_get(self): 4082 # Testing __get__ method of METH_CLASS C methods... 4083 # Full coverage of descrobject.c::classmethod_get() 4084 4085 # Baseline 4086 arg = [1, 2, 3] 4087 res = {1: None, 2: None, 3: None} 4088 self.assertEqual(dict.fromkeys(arg), res) 4089 self.assertEqual({}.fromkeys(arg), res) 4090 4091 # Now get the descriptor 4092 descr = dict.__dict__["fromkeys"] 4093 4094 # More baseline using the descriptor directly 4095 self.assertEqual(descr.__get__(None, dict)(arg), res) 4096 self.assertEqual(descr.__get__({})(arg), res) 4097 4098 # Now check various error cases 4099 try: 4100 descr.__get__(None, None) 4101 except TypeError: 4102 pass 4103 else: 4104 self.fail("shouldn't have allowed descr.__get__(None, None)") 4105 try: 4106 descr.__get__(42) 4107 except TypeError: 4108 pass 4109 else: 4110 self.fail("shouldn't have allowed descr.__get__(42)") 4111 try: 4112 descr.__get__(None, 42) 4113 except TypeError: 4114 pass 4115 else: 4116 self.fail("shouldn't have allowed descr.__get__(None, 42)") 4117 try: 4118 descr.__get__(None, int) 4119 except TypeError: 4120 pass 4121 else: 4122 self.fail("shouldn't have allowed descr.__get__(None, int)") 4123 4124 def test_isinst_isclass(self): 4125 # Testing proxy isinstance() and isclass()... 4126 class Proxy(object): 4127 def __init__(self, obj): 4128 self.__obj = obj 4129 def __getattribute__(self, name): 4130 if name.startswith("_Proxy__"): 4131 return object.__getattribute__(self, name) 4132 else: 4133 return getattr(self.__obj, name) 4134 # Test with a classic class 4135 class C: 4136 pass 4137 a = C() 4138 pa = Proxy(a) 4139 self.assertIsInstance(a, C) # Baseline 4140 self.assertIsInstance(pa, C) # Test 4141 # Test with a classic subclass 4142 class D(C): 4143 pass 4144 a = D() 4145 pa = Proxy(a) 4146 self.assertIsInstance(a, C) # Baseline 4147 self.assertIsInstance(pa, C) # Test 4148 # Test with a new-style class 4149 class C(object): 4150 pass 4151 a = C() 4152 pa = Proxy(a) 4153 self.assertIsInstance(a, C) # Baseline 4154 self.assertIsInstance(pa, C) # Test 4155 # Test with a new-style subclass 4156 class D(C): 4157 pass 4158 a = D() 4159 pa = Proxy(a) 4160 self.assertIsInstance(a, C) # Baseline 4161 self.assertIsInstance(pa, C) # Test 4162 4163 def test_proxy_super(self): 4164 # Testing super() for a proxy object... 4165 class Proxy(object): 4166 def __init__(self, obj): 4167 self.__obj = obj 4168 def __getattribute__(self, name): 4169 if name.startswith("_Proxy__"): 4170 return object.__getattribute__(self, name) 4171 else: 4172 return getattr(self.__obj, name) 4173 4174 class B(object): 4175 def f(self): 4176 return "B.f" 4177 4178 class C(B): 4179 def f(self): 4180 return super(C, self).f() + "->C.f" 4181 4182 obj = C() 4183 p = Proxy(obj) 4184 self.assertEqual(C.__dict__["f"](p), "B.f->C.f") 4185 4186 def test_carloverre(self): 4187 # Testing prohibition of Carlo Verre's hack... 4188 try: 4189 object.__setattr__(str, "foo", 42) 4190 except TypeError: 4191 pass 4192 else: 4193 self.fail("Carlo Verre __setattr__ succeeded!") 4194 try: 4195 object.__delattr__(str, "lower") 4196 except TypeError: 4197 pass 4198 else: 4199 self.fail("Carlo Verre __delattr__ succeeded!") 4200 4201 def test_weakref_segfault(self): 4202 # Testing weakref segfault... 4203 # SF 742911 4204 import weakref 4205 4206 class Provoker: 4207 def __init__(self, referrent): 4208 self.ref = weakref.ref(referrent) 4209 4210 def __del__(self): 4211 x = self.ref() 4212 4213 class Oops(object): 4214 pass 4215 4216 o = Oops() 4217 o.whatever = Provoker(o) 4218 del o 4219 4220 def test_wrapper_segfault(self): 4221 # SF 927248: deeply nested wrappers could cause stack overflow 4222 f = lambda:None 4223 for i in range(1000000): 4224 f = f.__call__ 4225 f = None 4226 4227 def test_file_fault(self): 4228 # Testing sys.stdout is changed in getattr... 4229 test_stdout = sys.stdout 4230 class StdoutGuard: 4231 def __getattr__(self, attr): 4232 sys.stdout = sys.__stdout__ 4233 raise RuntimeError("Premature access to sys.stdout.%s" % attr) 4234 sys.stdout = StdoutGuard() 4235 try: 4236 print("Oops!") 4237 except RuntimeError: 4238 pass 4239 finally: 4240 sys.stdout = test_stdout 4241 4242 def test_vicious_descriptor_nonsense(self): 4243 # Testing vicious_descriptor_nonsense... 4244 4245 # A potential segfault spotted by Thomas Wouters in mail to 4246 # python-dev 2003-04-17, turned into an example & fixed by Michael 4247 # Hudson just less than four months later... 4248 4249 class Evil(object): 4250 def __hash__(self): 4251 return hash('attr') 4252 def __eq__(self, other): 4253 del C.attr 4254 return 0 4255 4256 class Descr(object): 4257 def __get__(self, ob, type=None): 4258 return 1 4259 4260 class C(object): 4261 attr = Descr() 4262 4263 c = C() 4264 c.__dict__[Evil()] = 0 4265 4266 self.assertEqual(c.attr, 1) 4267 # this makes a crash more likely: 4268 support.gc_collect() 4269 self.assertNotHasAttr(c, 'attr') 4270 4271 def test_init(self): 4272 # SF 1155938 4273 class Foo(object): 4274 def __init__(self): 4275 return 10 4276 try: 4277 Foo() 4278 except TypeError: 4279 pass 4280 else: 4281 self.fail("did not test __init__() for None return") 4282 4283 def test_method_wrapper(self): 4284 # Testing method-wrapper objects... 4285 # <type 'method-wrapper'> did not support any reflection before 2.5 4286 4287 # XXX should methods really support __eq__? 4288 4289 l = [] 4290 self.assertEqual(l.__add__, l.__add__) 4291 self.assertEqual(l.__add__, [].__add__) 4292 self.assertNotEqual(l.__add__, [5].__add__) 4293 self.assertNotEqual(l.__add__, l.__mul__) 4294 self.assertEqual(l.__add__.__name__, '__add__') 4295 if hasattr(l.__add__, '__self__'): 4296 # CPython 4297 self.assertIs(l.__add__.__self__, l) 4298 self.assertIs(l.__add__.__objclass__, list) 4299 else: 4300 # Python implementations where [].__add__ is a normal bound method 4301 self.assertIs(l.__add__.im_self, l) 4302 self.assertIs(l.__add__.im_class, list) 4303 self.assertEqual(l.__add__.__doc__, list.__add__.__doc__) 4304 try: 4305 hash(l.__add__) 4306 except TypeError: 4307 pass 4308 else: 4309 self.fail("no TypeError from hash([].__add__)") 4310 4311 t = () 4312 t += (7,) 4313 self.assertEqual(t.__add__, (7,).__add__) 4314 self.assertEqual(hash(t.__add__), hash((7,).__add__)) 4315 4316 def test_not_implemented(self): 4317 # Testing NotImplemented... 4318 # all binary methods should be able to return a NotImplemented 4319 import operator 4320 4321 def specialmethod(self, other): 4322 return NotImplemented 4323 4324 def check(expr, x, y): 4325 try: 4326 exec(expr, {'x': x, 'y': y, 'operator': operator}) 4327 except TypeError: 4328 pass 4329 else: 4330 self.fail("no TypeError from %r" % (expr,)) 4331 4332 N1 = sys.maxsize + 1 # might trigger OverflowErrors instead of 4333 # TypeErrors 4334 N2 = sys.maxsize # if sizeof(int) < sizeof(long), might trigger 4335 # ValueErrors instead of TypeErrors 4336 for name, expr, iexpr in [ 4337 ('__add__', 'x + y', 'x += y'), 4338 ('__sub__', 'x - y', 'x -= y'), 4339 ('__mul__', 'x * y', 'x *= y'), 4340 ('__matmul__', 'x @ y', 'x @= y'), 4341 ('__truediv__', 'x / y', 'x /= y'), 4342 ('__floordiv__', 'x // y', 'x //= y'), 4343 ('__mod__', 'x % y', 'x %= y'), 4344 ('__divmod__', 'divmod(x, y)', None), 4345 ('__pow__', 'x ** y', 'x **= y'), 4346 ('__lshift__', 'x << y', 'x <<= y'), 4347 ('__rshift__', 'x >> y', 'x >>= y'), 4348 ('__and__', 'x & y', 'x &= y'), 4349 ('__or__', 'x | y', 'x |= y'), 4350 ('__xor__', 'x ^ y', 'x ^= y')]: 4351 rname = '__r' + name[2:] 4352 A = type('A', (), {name: specialmethod}) 4353 a = A() 4354 check(expr, a, a) 4355 check(expr, a, N1) 4356 check(expr, a, N2) 4357 if iexpr: 4358 check(iexpr, a, a) 4359 check(iexpr, a, N1) 4360 check(iexpr, a, N2) 4361 iname = '__i' + name[2:] 4362 C = type('C', (), {iname: specialmethod}) 4363 c = C() 4364 check(iexpr, c, a) 4365 check(iexpr, c, N1) 4366 check(iexpr, c, N2) 4367 4368 def test_assign_slice(self): 4369 # ceval.c's assign_slice used to check for 4370 # tp->tp_as_sequence->sq_slice instead of 4371 # tp->tp_as_sequence->sq_ass_slice 4372 4373 class C(object): 4374 def __setitem__(self, idx, value): 4375 self.value = value 4376 4377 c = C() 4378 c[1:2] = 3 4379 self.assertEqual(c.value, 3) 4380 4381 def test_set_and_no_get(self): 4382 # See 4383 # http://mail.python.org/pipermail/python-dev/2010-January/095637.html 4384 class Descr(object): 4385 4386 def __init__(self, name): 4387 self.name = name 4388 4389 def __set__(self, obj, value): 4390 obj.__dict__[self.name] = value 4391 descr = Descr("a") 4392 4393 class X(object): 4394 a = descr 4395 4396 x = X() 4397 self.assertIs(x.a, descr) 4398 x.a = 42 4399 self.assertEqual(x.a, 42) 4400 4401 # Also check type_getattro for correctness. 4402 class Meta(type): 4403 pass 4404 class X(metaclass=Meta): 4405 pass 4406 X.a = 42 4407 Meta.a = Descr("a") 4408 self.assertEqual(X.a, 42) 4409 4410 def test_getattr_hooks(self): 4411 # issue 4230 4412 4413 class Descriptor(object): 4414 counter = 0 4415 def __get__(self, obj, objtype=None): 4416 def getter(name): 4417 self.counter += 1 4418 raise AttributeError(name) 4419 return getter 4420 4421 descr = Descriptor() 4422 class A(object): 4423 __getattribute__ = descr 4424 class B(object): 4425 __getattr__ = descr 4426 class C(object): 4427 __getattribute__ = descr 4428 __getattr__ = descr 4429 4430 self.assertRaises(AttributeError, getattr, A(), "attr") 4431 self.assertEqual(descr.counter, 1) 4432 self.assertRaises(AttributeError, getattr, B(), "attr") 4433 self.assertEqual(descr.counter, 2) 4434 self.assertRaises(AttributeError, getattr, C(), "attr") 4435 self.assertEqual(descr.counter, 4) 4436 4437 class EvilGetattribute(object): 4438 # This used to segfault 4439 def __getattr__(self, name): 4440 raise AttributeError(name) 4441 def __getattribute__(self, name): 4442 del EvilGetattribute.__getattr__ 4443 for i in range(5): 4444 gc.collect() 4445 raise AttributeError(name) 4446 4447 self.assertRaises(AttributeError, getattr, EvilGetattribute(), "attr") 4448 4449 def test_type___getattribute__(self): 4450 self.assertRaises(TypeError, type.__getattribute__, list, type) 4451 4452 def test_abstractmethods(self): 4453 # type pretends not to have __abstractmethods__. 4454 self.assertRaises(AttributeError, getattr, type, "__abstractmethods__") 4455 class meta(type): 4456 pass 4457 self.assertRaises(AttributeError, getattr, meta, "__abstractmethods__") 4458 class X(object): 4459 pass 4460 with self.assertRaises(AttributeError): 4461 del X.__abstractmethods__ 4462 4463 def test_proxy_call(self): 4464 class FakeStr: 4465 __class__ = str 4466 4467 fake_str = FakeStr() 4468 # isinstance() reads __class__ 4469 self.assertIsInstance(fake_str, str) 4470 4471 # call a method descriptor 4472 with self.assertRaises(TypeError): 4473 str.split(fake_str) 4474 4475 # call a slot wrapper descriptor 4476 with self.assertRaises(TypeError): 4477 str.__add__(fake_str, "abc") 4478 4479 def test_repr_as_str(self): 4480 # Issue #11603: crash or infinite loop when rebinding __str__ as 4481 # __repr__. 4482 class Foo: 4483 pass 4484 Foo.__repr__ = Foo.__str__ 4485 foo = Foo() 4486 self.assertRaises(RecursionError, str, foo) 4487 self.assertRaises(RecursionError, repr, foo) 4488 4489 def test_mixing_slot_wrappers(self): 4490 class X(dict): 4491 __setattr__ = dict.__setitem__ 4492 x = X() 4493 x.y = 42 4494 self.assertEqual(x["y"], 42) 4495 4496 def test_slot_shadows_class_variable(self): 4497 with self.assertRaises(ValueError) as cm: 4498 class X: 4499 __slots__ = ["foo"] 4500 foo = None 4501 m = str(cm.exception) 4502 self.assertEqual("'foo' in __slots__ conflicts with class variable", m) 4503 4504 def test_set_doc(self): 4505 class X: 4506 "elephant" 4507 X.__doc__ = "banana" 4508 self.assertEqual(X.__doc__, "banana") 4509 with self.assertRaises(TypeError) as cm: 4510 type(list).__dict__["__doc__"].__set__(list, "blah") 4511 self.assertIn("can't set list.__doc__", str(cm.exception)) 4512 with self.assertRaises(TypeError) as cm: 4513 type(X).__dict__["__doc__"].__delete__(X) 4514 self.assertIn("can't delete X.__doc__", str(cm.exception)) 4515 self.assertEqual(X.__doc__, "banana") 4516 4517 def test_qualname(self): 4518 descriptors = [str.lower, complex.real, float.real, int.__add__] 4519 types = ['method', 'member', 'getset', 'wrapper'] 4520 4521 # make sure we have an example of each type of descriptor 4522 for d, n in zip(descriptors, types): 4523 self.assertEqual(type(d).__name__, n + '_descriptor') 4524 4525 for d in descriptors: 4526 qualname = d.__objclass__.__qualname__ + '.' + d.__name__ 4527 self.assertEqual(d.__qualname__, qualname) 4528 4529 self.assertEqual(str.lower.__qualname__, 'str.lower') 4530 self.assertEqual(complex.real.__qualname__, 'complex.real') 4531 self.assertEqual(float.real.__qualname__, 'float.real') 4532 self.assertEqual(int.__add__.__qualname__, 'int.__add__') 4533 4534 class X: 4535 pass 4536 with self.assertRaises(TypeError): 4537 del X.__qualname__ 4538 4539 self.assertRaises(TypeError, type.__dict__['__qualname__'].__set__, 4540 str, 'Oink') 4541 4542 global Y 4543 class Y: 4544 class Inside: 4545 pass 4546 self.assertEqual(Y.__qualname__, 'Y') 4547 self.assertEqual(Y.Inside.__qualname__, 'Y.Inside') 4548 4549 def test_qualname_dict(self): 4550 ns = {'__qualname__': 'some.name'} 4551 tp = type('Foo', (), ns) 4552 self.assertEqual(tp.__qualname__, 'some.name') 4553 self.assertNotIn('__qualname__', tp.__dict__) 4554 self.assertEqual(ns, {'__qualname__': 'some.name'}) 4555 4556 ns = {'__qualname__': 1} 4557 self.assertRaises(TypeError, type, 'Foo', (), ns) 4558 4559 def test_cycle_through_dict(self): 4560 # See bug #1469629 4561 class X(dict): 4562 def __init__(self): 4563 dict.__init__(self) 4564 self.__dict__ = self 4565 x = X() 4566 x.attr = 42 4567 wr = weakref.ref(x) 4568 del x 4569 support.gc_collect() 4570 self.assertIsNone(wr()) 4571 for o in gc.get_objects(): 4572 self.assertIsNot(type(o), X) 4573 4574 def test_object_new_and_init_with_parameters(self): 4575 # See issue #1683368 4576 class OverrideNeither: 4577 pass 4578 self.assertRaises(TypeError, OverrideNeither, 1) 4579 self.assertRaises(TypeError, OverrideNeither, kw=1) 4580 class OverrideNew: 4581 def __new__(cls, foo, kw=0, *args, **kwds): 4582 return object.__new__(cls, *args, **kwds) 4583 class OverrideInit: 4584 def __init__(self, foo, kw=0, *args, **kwargs): 4585 return object.__init__(self, *args, **kwargs) 4586 class OverrideBoth(OverrideNew, OverrideInit): 4587 pass 4588 for case in OverrideNew, OverrideInit, OverrideBoth: 4589 case(1) 4590 case(1, kw=2) 4591 self.assertRaises(TypeError, case, 1, 2, 3) 4592 self.assertRaises(TypeError, case, 1, 2, foo=3) 4593 4594 def test_subclassing_does_not_duplicate_dict_descriptors(self): 4595 class Base: 4596 pass 4597 class Sub(Base): 4598 pass 4599 self.assertIn("__dict__", Base.__dict__) 4600 self.assertNotIn("__dict__", Sub.__dict__) 4601 4602 def test_bound_method_repr(self): 4603 class Foo: 4604 def method(self): 4605 pass 4606 self.assertRegex(repr(Foo().method), 4607 r"<bound method .*Foo\.method of <.*Foo object at .*>>") 4608 4609 4610 class Base: 4611 def method(self): 4612 pass 4613 class Derived1(Base): 4614 pass 4615 class Derived2(Base): 4616 def method(self): 4617 pass 4618 base = Base() 4619 derived1 = Derived1() 4620 derived2 = Derived2() 4621 super_d2 = super(Derived2, derived2) 4622 self.assertRegex(repr(base.method), 4623 r"<bound method .*Base\.method of <.*Base object at .*>>") 4624 self.assertRegex(repr(derived1.method), 4625 r"<bound method .*Base\.method of <.*Derived1 object at .*>>") 4626 self.assertRegex(repr(derived2.method), 4627 r"<bound method .*Derived2\.method of <.*Derived2 object at .*>>") 4628 self.assertRegex(repr(super_d2.method), 4629 r"<bound method .*Base\.method of <.*Derived2 object at .*>>") 4630 4631 class Foo: 4632 @classmethod 4633 def method(cls): 4634 pass 4635 foo = Foo() 4636 self.assertRegex(repr(foo.method), # access via instance 4637 r"<bound method .*Foo\.method of <class '.*Foo'>>") 4638 self.assertRegex(repr(Foo.method), # access via the class 4639 r"<bound method .*Foo\.method of <class '.*Foo'>>") 4640 4641 4642 class MyCallable: 4643 def __call__(self, arg): 4644 pass 4645 func = MyCallable() # func has no __name__ or __qualname__ attributes 4646 instance = object() 4647 method = types.MethodType(func, instance) 4648 self.assertRegex(repr(method), 4649 r"<bound method \? of <object object at .*>>") 4650 func.__name__ = "name" 4651 self.assertRegex(repr(method), 4652 r"<bound method name of <object object at .*>>") 4653 func.__qualname__ = "qualname" 4654 self.assertRegex(repr(method), 4655 r"<bound method qualname of <object object at .*>>") 4656 4657 4658 class DictProxyTests(unittest.TestCase): 4659 def setUp(self): 4660 class C(object): 4661 def meth(self): 4662 pass 4663 self.C = C 4664 4665 @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 4666 'trace function introduces __local__') 4667 def test_iter_keys(self): 4668 # Testing dict-proxy keys... 4669 it = self.C.__dict__.keys() 4670 self.assertNotIsInstance(it, list) 4671 keys = list(it) 4672 keys.sort() 4673 self.assertEqual(keys, ['__dict__', '__doc__', '__module__', 4674 '__weakref__', 'meth']) 4675 4676 @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 4677 'trace function introduces __local__') 4678 def test_iter_values(self): 4679 # Testing dict-proxy values... 4680 it = self.C.__dict__.values() 4681 self.assertNotIsInstance(it, list) 4682 values = list(it) 4683 self.assertEqual(len(values), 5) 4684 4685 @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 4686 'trace function introduces __local__') 4687 def test_iter_items(self): 4688 # Testing dict-proxy iteritems... 4689 it = self.C.__dict__.items() 4690 self.assertNotIsInstance(it, list) 4691 keys = [item[0] for item in it] 4692 keys.sort() 4693 self.assertEqual(keys, ['__dict__', '__doc__', '__module__', 4694 '__weakref__', 'meth']) 4695 4696 def test_dict_type_with_metaclass(self): 4697 # Testing type of __dict__ when metaclass set... 4698 class B(object): 4699 pass 4700 class M(type): 4701 pass 4702 class C(metaclass=M): 4703 # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy 4704 pass 4705 self.assertEqual(type(C.__dict__), type(B.__dict__)) 4706 4707 def test_repr(self): 4708 # Testing mappingproxy.__repr__. 4709 # We can't blindly compare with the repr of another dict as ordering 4710 # of keys and values is arbitrary and may differ. 4711 r = repr(self.C.__dict__) 4712 self.assertTrue(r.startswith('mappingproxy('), r) 4713 self.assertTrue(r.endswith(')'), r) 4714 for k, v in self.C.__dict__.items(): 4715 self.assertIn('{!r}: {!r}'.format(k, v), r) 4716 4717 4718 class PTypesLongInitTest(unittest.TestCase): 4719 # This is in its own TestCase so that it can be run before any other tests. 4720 def test_pytype_long_ready(self): 4721 # Testing SF bug 551412 ... 4722 4723 # This dumps core when SF bug 551412 isn't fixed -- 4724 # but only when test_descr.py is run separately. 4725 # (That can't be helped -- as soon as PyType_Ready() 4726 # is called for PyLong_Type, the bug is gone.) 4727 class UserLong(object): 4728 def __pow__(self, *args): 4729 pass 4730 try: 4731 pow(0, UserLong(), 0) 4732 except: 4733 pass 4734 4735 # Another segfault only when run early 4736 # (before PyType_Ready(tuple) is called) 4737 type.mro(tuple) 4738 4739 4740 class MiscTests(unittest.TestCase): 4741 def test_type_lookup_mro_reference(self): 4742 # Issue #14199: _PyType_Lookup() has to keep a strong reference to 4743 # the type MRO because it may be modified during the lookup, if 4744 # __bases__ is set during the lookup for example. 4745 class MyKey(object): 4746 def __hash__(self): 4747 return hash('mykey') 4748 4749 def __eq__(self, other): 4750 X.__bases__ = (Base2,) 4751 4752 class Base(object): 4753 mykey = 'from Base' 4754 mykey2 = 'from Base' 4755 4756 class Base2(object): 4757 mykey = 'from Base2' 4758 mykey2 = 'from Base2' 4759 4760 X = type('X', (Base,), {MyKey(): 5}) 4761 # mykey is read from Base 4762 self.assertEqual(X.mykey, 'from Base') 4763 # mykey2 is read from Base2 because MyKey.__eq__ has set __bases__ 4764 self.assertEqual(X.mykey2, 'from Base2') 4765 4766 4767 class PicklingTests(unittest.TestCase): 4768 4769 def _check_reduce(self, proto, obj, args=(), kwargs={}, state=None, 4770 listitems=None, dictitems=None): 4771 if proto >= 2: 4772 reduce_value = obj.__reduce_ex__(proto) 4773 if kwargs: 4774 self.assertEqual(reduce_value[0], copyreg.__newobj_ex__) 4775 self.assertEqual(reduce_value[1], (type(obj), args, kwargs)) 4776 else: 4777 self.assertEqual(reduce_value[0], copyreg.__newobj__) 4778 self.assertEqual(reduce_value[1], (type(obj),) + args) 4779 self.assertEqual(reduce_value[2], state) 4780 if listitems is not None: 4781 self.assertListEqual(list(reduce_value[3]), listitems) 4782 else: 4783 self.assertIsNone(reduce_value[3]) 4784 if dictitems is not None: 4785 self.assertDictEqual(dict(reduce_value[4]), dictitems) 4786 else: 4787 self.assertIsNone(reduce_value[4]) 4788 else: 4789 base_type = type(obj).__base__ 4790 reduce_value = (copyreg._reconstructor, 4791 (type(obj), 4792 base_type, 4793 None if base_type is object else base_type(obj))) 4794 if state is not None: 4795 reduce_value += (state,) 4796 self.assertEqual(obj.__reduce_ex__(proto), reduce_value) 4797 self.assertEqual(obj.__reduce__(), reduce_value) 4798 4799 def test_reduce(self): 4800 protocols = range(pickle.HIGHEST_PROTOCOL + 1) 4801 args = (-101, "spam") 4802 kwargs = {'bacon': -201, 'fish': -301} 4803 state = {'cheese': -401} 4804 4805 class C1: 4806 def __getnewargs__(self): 4807 return args 4808 obj = C1() 4809 for proto in protocols: 4810 self._check_reduce(proto, obj, args) 4811 4812 for name, value in state.items(): 4813 setattr(obj, name, value) 4814 for proto in protocols: 4815 self._check_reduce(proto, obj, args, state=state) 4816 4817 class C2: 4818 def __getnewargs__(self): 4819 return "bad args" 4820 obj = C2() 4821 for proto in protocols: 4822 if proto >= 2: 4823 with self.assertRaises(TypeError): 4824 obj.__reduce_ex__(proto) 4825 4826 class C3: 4827 def __getnewargs_ex__(self): 4828 return (args, kwargs) 4829 obj = C3() 4830 for proto in protocols: 4831 if proto >= 2: 4832 self._check_reduce(proto, obj, args, kwargs) 4833 4834 class C4: 4835 def __getnewargs_ex__(self): 4836 return (args, "bad dict") 4837 class C5: 4838 def __getnewargs_ex__(self): 4839 return ("bad tuple", kwargs) 4840 class C6: 4841 def __getnewargs_ex__(self): 4842 return () 4843 class C7: 4844 def __getnewargs_ex__(self): 4845 return "bad args" 4846 for proto in protocols: 4847 for cls in C4, C5, C6, C7: 4848 obj = cls() 4849 if proto >= 2: 4850 with self.assertRaises((TypeError, ValueError)): 4851 obj.__reduce_ex__(proto) 4852 4853 class C9: 4854 def __getnewargs_ex__(self): 4855 return (args, {}) 4856 obj = C9() 4857 for proto in protocols: 4858 self._check_reduce(proto, obj, args) 4859 4860 class C10: 4861 def __getnewargs_ex__(self): 4862 raise IndexError 4863 obj = C10() 4864 for proto in protocols: 4865 if proto >= 2: 4866 with self.assertRaises(IndexError): 4867 obj.__reduce_ex__(proto) 4868 4869 class C11: 4870 def __getstate__(self): 4871 return state 4872 obj = C11() 4873 for proto in protocols: 4874 self._check_reduce(proto, obj, state=state) 4875 4876 class C12: 4877 def __getstate__(self): 4878 return "not dict" 4879 obj = C12() 4880 for proto in protocols: 4881 self._check_reduce(proto, obj, state="not dict") 4882 4883 class C13: 4884 def __getstate__(self): 4885 raise IndexError 4886 obj = C13() 4887 for proto in protocols: 4888 with self.assertRaises(IndexError): 4889 obj.__reduce_ex__(proto) 4890 if proto < 2: 4891 with self.assertRaises(IndexError): 4892 obj.__reduce__() 4893 4894 class C14: 4895 __slots__ = tuple(state) 4896 def __init__(self): 4897 for name, value in state.items(): 4898 setattr(self, name, value) 4899 4900 obj = C14() 4901 for proto in protocols: 4902 if proto >= 2: 4903 self._check_reduce(proto, obj, state=(None, state)) 4904 else: 4905 with self.assertRaises(TypeError): 4906 obj.__reduce_ex__(proto) 4907 with self.assertRaises(TypeError): 4908 obj.__reduce__() 4909 4910 class C15(dict): 4911 pass 4912 obj = C15({"quebec": -601}) 4913 for proto in protocols: 4914 self._check_reduce(proto, obj, dictitems=dict(obj)) 4915 4916 class C16(list): 4917 pass 4918 obj = C16(["yukon"]) 4919 for proto in protocols: 4920 self._check_reduce(proto, obj, listitems=list(obj)) 4921 4922 def test_special_method_lookup(self): 4923 protocols = range(pickle.HIGHEST_PROTOCOL + 1) 4924 class Picky: 4925 def __getstate__(self): 4926 return {} 4927 4928 def __getattr__(self, attr): 4929 if attr in ("__getnewargs__", "__getnewargs_ex__"): 4930 raise AssertionError(attr) 4931 return None 4932 for protocol in protocols: 4933 state = {} if protocol >= 2 else None 4934 self._check_reduce(protocol, Picky(), state=state) 4935 4936 def _assert_is_copy(self, obj, objcopy, msg=None): 4937 """Utility method to verify if two objects are copies of each others. 4938 """ 4939 if msg is None: 4940 msg = "{!r} is not a copy of {!r}".format(obj, objcopy) 4941 if type(obj).__repr__ is object.__repr__: 4942 # We have this limitation for now because we use the object's repr 4943 # to help us verify that the two objects are copies. This allows 4944 # us to delegate the non-generic verification logic to the objects 4945 # themselves. 4946 raise ValueError("object passed to _assert_is_copy must " + 4947 "override the __repr__ method.") 4948 self.assertIsNot(obj, objcopy, msg=msg) 4949 self.assertIs(type(obj), type(objcopy), msg=msg) 4950 if hasattr(obj, '__dict__'): 4951 self.assertDictEqual(obj.__dict__, objcopy.__dict__, msg=msg) 4952 self.assertIsNot(obj.__dict__, objcopy.__dict__, msg=msg) 4953 if hasattr(obj, '__slots__'): 4954 self.assertListEqual(obj.__slots__, objcopy.__slots__, msg=msg) 4955 for slot in obj.__slots__: 4956 self.assertEqual( 4957 hasattr(obj, slot), hasattr(objcopy, slot), msg=msg) 4958 self.assertEqual(getattr(obj, slot, None), 4959 getattr(objcopy, slot, None), msg=msg) 4960 self.assertEqual(repr(obj), repr(objcopy), msg=msg) 4961 4962 @staticmethod 4963 def _generate_pickle_copiers(): 4964 """Utility method to generate the many possible pickle configurations. 4965 """ 4966 class PickleCopier: 4967 "This class copies object using pickle." 4968 def __init__(self, proto, dumps, loads): 4969 self.proto = proto 4970 self.dumps = dumps 4971 self.loads = loads 4972 def copy(self, obj): 4973 return self.loads(self.dumps(obj, self.proto)) 4974 def __repr__(self): 4975 # We try to be as descriptive as possible here since this is 4976 # the string which we will allow us to tell the pickle 4977 # configuration we are using during debugging. 4978 return ("PickleCopier(proto={}, dumps={}.{}, loads={}.{})" 4979 .format(self.proto, 4980 self.dumps.__module__, self.dumps.__qualname__, 4981 self.loads.__module__, self.loads.__qualname__)) 4982 return (PickleCopier(*args) for args in 4983 itertools.product(range(pickle.HIGHEST_PROTOCOL + 1), 4984 {pickle.dumps, pickle._dumps}, 4985 {pickle.loads, pickle._loads})) 4986 4987 def test_pickle_slots(self): 4988 # Tests pickling of classes with __slots__. 4989 4990 # Pickling of classes with __slots__ but without __getstate__ should 4991 # fail (if using protocol 0 or 1) 4992 global C 4993 class C: 4994 __slots__ = ['a'] 4995 with self.assertRaises(TypeError): 4996 pickle.dumps(C(), 0) 4997 4998 global D 4999 class D(C): 5000 pass 5001 with self.assertRaises(TypeError): 5002 pickle.dumps(D(), 0) 5003 5004 class C: 5005 "A class with __getstate__ and __setstate__ implemented." 5006 __slots__ = ['a'] 5007 def __getstate__(self): 5008 state = getattr(self, '__dict__', {}).copy() 5009 for cls in type(self).__mro__: 5010 for slot in cls.__dict__.get('__slots__', ()): 5011 try: 5012 state[slot] = getattr(self, slot) 5013 except AttributeError: 5014 pass 5015 return state 5016 def __setstate__(self, state): 5017 for k, v in state.items(): 5018 setattr(self, k, v) 5019 def __repr__(self): 5020 return "%s()<%r>" % (type(self).__name__, self.__getstate__()) 5021 5022 class D(C): 5023 "A subclass of a class with slots." 5024 pass 5025 5026 global E 5027 class E(C): 5028 "A subclass with an extra slot." 5029 __slots__ = ['b'] 5030 5031 # Now it should work 5032 for pickle_copier in self._generate_pickle_copiers(): 5033 with self.subTest(pickle_copier=pickle_copier): 5034 x = C() 5035 y = pickle_copier.copy(x) 5036 self._assert_is_copy(x, y) 5037 5038 x.a = 42 5039 y = pickle_copier.copy(x) 5040 self._assert_is_copy(x, y) 5041 5042 x = D() 5043 x.a = 42 5044 x.b = 100 5045 y = pickle_copier.copy(x) 5046 self._assert_is_copy(x, y) 5047 5048 x = E() 5049 x.a = 42 5050 x.b = "foo" 5051 y = pickle_copier.copy(x) 5052 self._assert_is_copy(x, y) 5053 5054 def test_reduce_copying(self): 5055 # Tests pickling and copying new-style classes and objects. 5056 global C1 5057 class C1: 5058 "The state of this class is copyable via its instance dict." 5059 ARGS = (1, 2) 5060 NEED_DICT_COPYING = True 5061 def __init__(self, a, b): 5062 super().__init__() 5063 self.a = a 5064 self.b = b 5065 def __repr__(self): 5066 return "C1(%r, %r)" % (self.a, self.b) 5067 5068 global C2 5069 class C2(list): 5070 "A list subclass copyable via __getnewargs__." 5071 ARGS = (1, 2) 5072 NEED_DICT_COPYING = False 5073 def __new__(cls, a, b): 5074 self = super().__new__(cls) 5075 self.a = a 5076 self.b = b 5077 return self 5078 def __init__(self, *args): 5079 super().__init__() 5080 # This helps testing that __init__ is not called during the 5081 # unpickling process, which would cause extra appends. 5082 self.append("cheese") 5083 @classmethod 5084 def __getnewargs__(cls): 5085 return cls.ARGS 5086 def __repr__(self): 5087 return "C2(%r, %r)<%r>" % (self.a, self.b, list(self)) 5088 5089 global C3 5090 class C3(list): 5091 "A list subclass copyable via __getstate__." 5092 ARGS = (1, 2) 5093 NEED_DICT_COPYING = False 5094 def __init__(self, a, b): 5095 self.a = a 5096 self.b = b 5097 # This helps testing that __init__ is not called during the 5098 # unpickling process, which would cause extra appends. 5099 self.append("cheese") 5100 @classmethod 5101 def __getstate__(cls): 5102 return cls.ARGS 5103 def __setstate__(self, state): 5104 a, b = state 5105 self.a = a 5106 self.b = b 5107 def __repr__(self): 5108 return "C3(%r, %r)<%r>" % (self.a, self.b, list(self)) 5109 5110 global C4 5111 class C4(int): 5112 "An int subclass copyable via __getnewargs__." 5113 ARGS = ("hello", "world", 1) 5114 NEED_DICT_COPYING = False 5115 def __new__(cls, a, b, value): 5116 self = super().__new__(cls, value) 5117 self.a = a 5118 self.b = b 5119 return self 5120 @classmethod 5121 def __getnewargs__(cls): 5122 return cls.ARGS 5123 def __repr__(self): 5124 return "C4(%r, %r)<%r>" % (self.a, self.b, int(self)) 5125 5126 global C5 5127 class C5(int): 5128 "An int subclass copyable via __getnewargs_ex__." 5129 ARGS = (1, 2) 5130 KWARGS = {'value': 3} 5131 NEED_DICT_COPYING = False 5132 def __new__(cls, a, b, *, value=0): 5133 self = super().__new__(cls, value) 5134 self.a = a 5135 self.b = b 5136 return self 5137 @classmethod 5138 def __getnewargs_ex__(cls): 5139 return (cls.ARGS, cls.KWARGS) 5140 def __repr__(self): 5141 return "C5(%r, %r)<%r>" % (self.a, self.b, int(self)) 5142 5143 test_classes = (C1, C2, C3, C4, C5) 5144 # Testing copying through pickle 5145 pickle_copiers = self._generate_pickle_copiers() 5146 for cls, pickle_copier in itertools.product(test_classes, pickle_copiers): 5147 with self.subTest(cls=cls, pickle_copier=pickle_copier): 5148 kwargs = getattr(cls, 'KWARGS', {}) 5149 obj = cls(*cls.ARGS, **kwargs) 5150 proto = pickle_copier.proto 5151 objcopy = pickle_copier.copy(obj) 5152 self._assert_is_copy(obj, objcopy) 5153 # For test classes that supports this, make sure we didn't go 5154 # around the reduce protocol by simply copying the attribute 5155 # dictionary. We clear attributes using the previous copy to 5156 # not mutate the original argument. 5157 if proto >= 2 and not cls.NEED_DICT_COPYING: 5158 objcopy.__dict__.clear() 5159 objcopy2 = pickle_copier.copy(objcopy) 5160 self._assert_is_copy(obj, objcopy2) 5161 5162 # Testing copying through copy.deepcopy() 5163 for cls in test_classes: 5164 with self.subTest(cls=cls): 5165 kwargs = getattr(cls, 'KWARGS', {}) 5166 obj = cls(*cls.ARGS, **kwargs) 5167 objcopy = deepcopy(obj) 5168 self._assert_is_copy(obj, objcopy) 5169 # For test classes that supports this, make sure we didn't go 5170 # around the reduce protocol by simply copying the attribute 5171 # dictionary. We clear attributes using the previous copy to 5172 # not mutate the original argument. 5173 if not cls.NEED_DICT_COPYING: 5174 objcopy.__dict__.clear() 5175 objcopy2 = deepcopy(objcopy) 5176 self._assert_is_copy(obj, objcopy2) 5177 5178 def test_issue24097(self): 5179 # Slot name is freed inside __getattr__ and is later used. 5180 class S(str): # Not interned 5181 pass 5182 class A: 5183 __slotnames__ = [S('spam')] 5184 def __getattr__(self, attr): 5185 if attr == 'spam': 5186 A.__slotnames__[:] = [S('spam')] 5187 return 42 5188 else: 5189 raise AttributeError 5190 5191 import copyreg 5192 expected = (copyreg.__newobj__, (A,), (None, {'spam': 42}), None, None) 5193 self.assertEqual(A().__reduce__(2), expected) # Shouldn't crash 5194 5195 5196 class SharedKeyTests(unittest.TestCase): 5197 5198 @support.cpython_only 5199 def test_subclasses(self): 5200 # Verify that subclasses can share keys (per PEP 412) 5201 class A: 5202 pass 5203 class B(A): 5204 pass 5205 5206 a, b = A(), B() 5207 self.assertEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(b))) 5208 self.assertLess(sys.getsizeof(vars(a)), sys.getsizeof({})) 5209 # Initial hash table can contain at most 5 elements. 5210 # Set 6 attributes to cause internal resizing. 5211 a.x, a.y, a.z, a.w, a.v, a.u = range(6) 5212 self.assertNotEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(b))) 5213 a2 = A() 5214 self.assertEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(a2))) 5215 self.assertLess(sys.getsizeof(vars(a)), sys.getsizeof({})) 5216 b.u, b.v, b.w, b.t, b.s, b.r = range(6) 5217 self.assertLess(sys.getsizeof(vars(b)), sys.getsizeof({})) 5218 5219 5220 class DebugHelperMeta(type): 5221 """ 5222 Sets default __doc__ and simplifies repr() output. 5223 """ 5224 def __new__(mcls, name, bases, attrs): 5225 if attrs.get('__doc__') is None: 5226 attrs['__doc__'] = name # helps when debugging with gdb 5227 return type.__new__(mcls, name, bases, attrs) 5228 def __repr__(cls): 5229 return repr(cls.__name__) 5230 5231 5232 class MroTest(unittest.TestCase): 5233 """ 5234 Regressions for some bugs revealed through 5235 mcsl.mro() customization (typeobject.c: mro_internal()) and 5236 cls.__bases__ assignment (typeobject.c: type_set_bases()). 5237 """ 5238 5239 def setUp(self): 5240 self.step = 0 5241 self.ready = False 5242 5243 def step_until(self, limit): 5244 ret = (self.step < limit) 5245 if ret: 5246 self.step += 1 5247 return ret 5248 5249 def test_incomplete_set_bases_on_self(self): 5250 """ 5251 type_set_bases must be aware that type->tp_mro can be NULL. 5252 """ 5253 class M(DebugHelperMeta): 5254 def mro(cls): 5255 if self.step_until(1): 5256 assert cls.__mro__ is None 5257 cls.__bases__ += () 5258 5259 return type.mro(cls) 5260 5261 class A(metaclass=M): 5262 pass 5263 5264 def test_reent_set_bases_on_base(self): 5265 """ 5266 Deep reentrancy must not over-decref old_mro. 5267 """ 5268 class M(DebugHelperMeta): 5269 def mro(cls): 5270 if cls.__mro__ is not None and cls.__name__ == 'B': 5271 # 4-5 steps are usually enough to make it crash somewhere 5272 if self.step_until(10): 5273 A.__bases__ += () 5274 5275 return type.mro(cls) 5276 5277 class A(metaclass=M): 5278 pass 5279 class B(A): 5280 pass 5281 B.__bases__ += () 5282 5283 def test_reent_set_bases_on_direct_base(self): 5284 """ 5285 Similar to test_reent_set_bases_on_base, but may crash differently. 5286 """ 5287 class M(DebugHelperMeta): 5288 def mro(cls): 5289 base = cls.__bases__[0] 5290 if base is not object: 5291 if self.step_until(5): 5292 base.__bases__ += () 5293 5294 return type.mro(cls) 5295 5296 class A(metaclass=M): 5297 pass 5298 class B(A): 5299 pass 5300 class C(B): 5301 pass 5302 5303 def test_reent_set_bases_tp_base_cycle(self): 5304 """ 5305 type_set_bases must check for an inheritance cycle not only through 5306 MRO of the type, which may be not yet updated in case of reentrance, 5307 but also through tp_base chain, which is assigned before diving into 5308 inner calls to mro(). 5309 5310 Otherwise, the following snippet can loop forever: 5311 do { 5312 // ... 5313 type = type->tp_base; 5314 } while (type != NULL); 5315 5316 Functions that rely on tp_base (like solid_base and PyType_IsSubtype) 5317 would not be happy in that case, causing a stack overflow. 5318 """ 5319 class M(DebugHelperMeta): 5320 def mro(cls): 5321 if self.ready: 5322 if cls.__name__ == 'B1': 5323 B2.__bases__ = (B1,) 5324 if cls.__name__ == 'B2': 5325 B1.__bases__ = (B2,) 5326 return type.mro(cls) 5327 5328 class A(metaclass=M): 5329 pass 5330 class B1(A): 5331 pass 5332 class B2(A): 5333 pass 5334 5335 self.ready = True 5336 with self.assertRaises(TypeError): 5337 B1.__bases__ += () 5338 5339 def test_tp_subclasses_cycle_in_update_slots(self): 5340 """ 5341 type_set_bases must check for reentrancy upon finishing its job 5342 by updating tp_subclasses of old/new bases of the type. 5343 Otherwise, an implicit inheritance cycle through tp_subclasses 5344 can break functions that recurse on elements of that field 5345 (like recurse_down_subclasses and mro_hierarchy) eventually 5346 leading to a stack overflow. 5347 """ 5348 class M(DebugHelperMeta): 5349 def mro(cls): 5350 if self.ready and cls.__name__ == 'C': 5351 self.ready = False 5352 C.__bases__ = (B2,) 5353 return type.mro(cls) 5354 5355 class A(metaclass=M): 5356 pass 5357 class B1(A): 5358 pass 5359 class B2(A): 5360 pass 5361 class C(A): 5362 pass 5363 5364 self.ready = True 5365 C.__bases__ = (B1,) 5366 B1.__bases__ = (C,) 5367 5368 self.assertEqual(C.__bases__, (B2,)) 5369 self.assertEqual(B2.__subclasses__(), [C]) 5370 self.assertEqual(B1.__subclasses__(), []) 5371 5372 self.assertEqual(B1.__bases__, (C,)) 5373 self.assertEqual(C.__subclasses__(), [B1]) 5374 5375 def test_tp_subclasses_cycle_error_return_path(self): 5376 """ 5377 The same as test_tp_subclasses_cycle_in_update_slots, but tests 5378 a code path executed on error (goto bail). 5379 """ 5380 class E(Exception): 5381 pass 5382 class M(DebugHelperMeta): 5383 def mro(cls): 5384 if self.ready and cls.__name__ == 'C': 5385 if C.__bases__ == (B2,): 5386 self.ready = False 5387 else: 5388 C.__bases__ = (B2,) 5389 raise E 5390 return type.mro(cls) 5391 5392 class A(metaclass=M): 5393 pass 5394 class B1(A): 5395 pass 5396 class B2(A): 5397 pass 5398 class C(A): 5399 pass 5400 5401 self.ready = True 5402 with self.assertRaises(E): 5403 C.__bases__ = (B1,) 5404 B1.__bases__ = (C,) 5405 5406 self.assertEqual(C.__bases__, (B2,)) 5407 self.assertEqual(C.__mro__, tuple(type.mro(C))) 5408 5409 def test_incomplete_extend(self): 5410 """ 5411 Extending an unitialized type with type->tp_mro == NULL must 5412 throw a reasonable TypeError exception, instead of failing 5413 with PyErr_BadInternalCall. 5414 """ 5415 class M(DebugHelperMeta): 5416 def mro(cls): 5417 if cls.__mro__ is None and cls.__name__ != 'X': 5418 with self.assertRaises(TypeError): 5419 class X(cls): 5420 pass 5421 5422 return type.mro(cls) 5423 5424 class A(metaclass=M): 5425 pass 5426 5427 def test_incomplete_super(self): 5428 """ 5429 Attrubute lookup on a super object must be aware that 5430 its target type can be uninitialized (type->tp_mro == NULL). 5431 """ 5432 class M(DebugHelperMeta): 5433 def mro(cls): 5434 if cls.__mro__ is None: 5435 with self.assertRaises(AttributeError): 5436 super(cls, cls).xxx 5437 5438 return type.mro(cls) 5439 5440 class A(metaclass=M): 5441 pass 5442 5443 5444 def test_main(): 5445 # Run all local test cases, with PTypesLongInitTest first. 5446 support.run_unittest(PTypesLongInitTest, OperatorsTest, 5447 ClassPropertiesAndMethods, DictProxyTests, 5448 MiscTests, PicklingTests, SharedKeyTests, 5449 MroTest) 5450 5451 if __name__ == "__main__": 5452 test_main() 5453
