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