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