Lib/test/test_descr.py

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