diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 8670ff9ccf6..d28a84aa6e9 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -1,4137 +1,3980 @@ -# Test enhancements related to descriptors and new-style classes - -# XXX Please, please, please, someone convert this to unittest style! -from test.test_support import verify, vereq, verbose, TestFailed, TESTFN, get_original_stdout -from copy import deepcopy import types +import unittest +import warnings -def veris(a, b): - if a is not b: - raise TestFailed("%r is %r" % (a, b)) +from copy import deepcopy +from test import test_support -def testunop(a, res, expr="len(a)", meth="__len__"): - if verbose: print("checking", expr) - dict = {'a': a} - vereq(eval(expr, dict), res) - t = type(a) - m = getattr(t, meth) - while meth not in t.__dict__: - t = t.__bases__[0] - vereq(m, t.__dict__[meth]) - vereq(m(a), res) - bm = getattr(a, meth) - vereq(bm(), res) -def testbinop(a, b, res, expr="a+b", meth="__add__"): - if verbose: print("checking", expr) - dict = {'a': a, 'b': b} +class OperatorsTest(unittest.TestCase): - vereq(eval(expr, dict), res) - t = type(a) - m = getattr(t, meth) - while meth not in t.__dict__: - t = t.__bases__[0] - vereq(m, t.__dict__[meth]) - vereq(m(a, b), res) - bm = getattr(a, meth) - vereq(bm(b), res) + def __init__(self, *args, **kwargs): + unittest.TestCase.__init__(self, *args, **kwargs) + self.binops = { + 'add': '+', + 'sub': '-', + 'mul': '*', + 'div': '/', + 'divmod': 'divmod', + 'pow': '**', + 'lshift': '<<', + 'rshift': '>>', + 'and': '&', + 'xor': '^', + 'or': '|', + 'cmp': 'cmp', + 'lt': '<', + 'le': '<=', + 'eq': '==', + 'ne': '!=', + 'gt': '>', + 'ge': '>=', + } -def testsliceop(a, b, c, res, expr="a[b:c]", meth="__getitem__"): - if verbose: print("checking", expr) - dict = {'a': a, 'b': b, 'c': c} - vereq(eval(expr, dict), res) - t = type(a) - m = getattr(t, meth) - while meth not in t.__dict__: - t = t.__bases__[0] - vereq(m, t.__dict__[meth]) - vereq(m(a, slice(b, c)), res) - bm = getattr(a, meth) - vereq(bm(slice(b, c)), res) + for name, expr in list(self.binops.items()): + if expr.islower(): + expr = expr + "(a, b)" + else: + expr = 'a %s b' % expr + self.binops[name] = expr -def testsetop(a, b, res, stmt="a+=b", meth="__iadd__"): - if verbose: print("checking", stmt) - dict = {'a': deepcopy(a), 'b': b} - exec(stmt, dict) - vereq(dict['a'], res) - t = type(a) - m = getattr(t, meth) - while meth not in t.__dict__: - t = t.__bases__[0] - vereq(m, t.__dict__[meth]) - dict['a'] = deepcopy(a) - m(dict['a'], b) - vereq(dict['a'], res) - dict['a'] = deepcopy(a) - bm = getattr(dict['a'], meth) - bm(b) - vereq(dict['a'], res) + self.unops = { + 'pos': '+', + 'neg': '-', + 'abs': 'abs', + 'invert': '~', + 'int': 'int', + 'float': 'float', + 'oct': 'oct', + 'hex': 'hex', + } -def testset2op(a, b, c, res, stmt="a[b]=c", meth="__setitem__"): - if verbose: print("checking", stmt) - dict = {'a': deepcopy(a), 'b': b, 'c': c} - exec(stmt, dict) - vereq(dict['a'], res) - t = type(a) - m = getattr(t, meth) - while meth not in t.__dict__: - t = t.__bases__[0] - vereq(m, t.__dict__[meth]) - dict['a'] = deepcopy(a) - m(dict['a'], b, c) - vereq(dict['a'], res) - dict['a'] = deepcopy(a) - bm = getattr(dict['a'], meth) - bm(b, c) - vereq(dict['a'], res) + for name, expr in list(self.unops.items()): + if expr.islower(): + expr = expr + "(a)" + else: + expr = '%s a' % expr + self.unops[name] = expr -def testsetsliceop(a, b, c, d, res, stmt="a[b:c]=d", meth="__setitem__"): - if verbose: print("checking", stmt) - dict = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d} - exec(stmt, dict) - vereq(dict['a'], res) - t = type(a) - while meth not in t.__dict__: - t = t.__bases__[0] - m = getattr(t, meth) - vereq(m, t.__dict__[meth]) - dict['a'] = deepcopy(a) - m(dict['a'], slice(b, c), d) - vereq(dict['a'], res) - dict['a'] = deepcopy(a) - bm = getattr(dict['a'], meth) - bm(slice(b, c), d) - vereq(dict['a'], res) + def unop_test(self, a, res, expr="len(a)", meth="__len__"): + d = {'a': a} + self.assertEqual(eval(expr, d), res) + t = type(a) + m = getattr(t, meth) -def class_docstrings(): - class Classic: - "A classic docstring." - vereq(Classic.__doc__, "A classic docstring.") - vereq(Classic.__dict__['__doc__'], "A classic docstring.") + # Find method in parent class + while meth not in t.__dict__: + t = t.__bases__[0] - class Classic2: - pass - verify(Classic2.__doc__ is None) + self.assertEqual(m, t.__dict__[meth]) + self.assertEqual(m(a), res) + bm = getattr(a, meth) + self.assertEqual(bm(), res) - class NewStatic(object): - "Another docstring." - vereq(NewStatic.__doc__, "Another docstring.") - vereq(NewStatic.__dict__['__doc__'], "Another docstring.") + def binop_test(self, a, b, res, expr="a+b", meth="__add__"): + d = {'a': a, 'b': b} - class NewStatic2(object): - pass - verify(NewStatic2.__doc__ is None) + # XXX Hack so this passes before 2.3 when -Qnew is specified. + if meth == "__div__" and 1/2 == 0.5: + meth = "__truediv__" - class NewDynamic(object): - "Another docstring." - vereq(NewDynamic.__doc__, "Another docstring.") - vereq(NewDynamic.__dict__['__doc__'], "Another docstring.") + if meth == '__divmod__': pass - class NewDynamic2(object): - pass - verify(NewDynamic2.__doc__ is None) + self.assertEqual(eval(expr, d), res) + t = type(a) + m = getattr(t, meth) + while meth not in t.__dict__: + t = t.__bases__[0] + self.assertEqual(m, t.__dict__[meth]) + self.assertEqual(m(a, b), res) + bm = getattr(a, meth) + self.assertEqual(bm(b), res) -def lists(): - if verbose: print("Testing list operations...") - testbinop([1], [2], [1,2], "a+b", "__add__") - testbinop([1,2,3], 2, 1, "b in a", "__contains__") - testbinop([1,2,3], 4, 0, "b in a", "__contains__") - testbinop([1,2,3], 1, 2, "a[b]", "__getitem__") - testsliceop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getitem__") - testsetop([1], [2], [1,2], "a+=b", "__iadd__") - testsetop([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__") - testunop([1,2,3], 3, "len(a)", "__len__") - testbinop([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__") - testbinop([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__") - testset2op([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__") - testsetsliceop([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", - "__setitem__") + def sliceop_test(self, a, b, c, res, expr="a[b:c]", meth="__getitem__"): + d = {'a': a, 'b': b, 'c': c} + self.assertEqual(eval(expr, d), res) + t = type(a) + m = getattr(t, meth) + while meth not in t.__dict__: + t = t.__bases__[0] + self.assertEqual(m, t.__dict__[meth]) + self.assertEqual(m(a, slice(b, c)), res) + bm = getattr(a, meth) + self.assertEqual(bm(slice(b, c)), res) -def dicts(): - if verbose: print("Testing dict operations...") - ##testbinop({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__") - testbinop({1:2,3:4}, 1, 1, "b in a", "__contains__") - testbinop({1:2,3:4}, 2, 0, "b in a", "__contains__") - testbinop({1:2,3:4}, 1, 2, "a[b]", "__getitem__") - d = {1:2,3:4} - l1 = [] - for i in d.keys(): l1.append(i) - l = [] - for i in iter(d): l.append(i) - vereq(l, l1) - l = [] - for i in d.__iter__(): l.append(i) - vereq(l, l1) - l = [] - for i in dict.__iter__(d): l.append(i) - vereq(l, l1) - d = {1:2, 3:4} - testunop(d, 2, "len(a)", "__len__") - vereq(eval(repr(d), {}), d) - vereq(eval(d.__repr__(), {}), d) - testset2op({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c", "__setitem__") + def setop_test(self, a, b, res, stmt="a+=b", meth="__iadd__"): + d = {'a': deepcopy(a), 'b': b} + exec(stmt, d) + self.assertEqual(d['a'], res) + t = type(a) + m = getattr(t, meth) + while meth not in t.__dict__: + t = t.__bases__[0] + self.assertEqual(m, t.__dict__[meth]) + d['a'] = deepcopy(a) + m(d['a'], b) + self.assertEqual(d['a'], res) + d['a'] = deepcopy(a) + bm = getattr(d['a'], meth) + bm(b) + self.assertEqual(d['a'], res) -def dict_constructor(): - if verbose: - print("Testing dict constructor ...") - d = dict() - vereq(d, {}) - d = dict({}) - vereq(d, {}) - d = dict({1: 2, 'a': 'b'}) - vereq(d, {1: 2, 'a': 'b'}) - vereq(d, dict(d.items())) - vereq(d, dict(d.items())) - d = dict({'one':1, 'two':2}) - vereq(d, dict(one=1, two=2)) - vereq(d, dict(**d)) - vereq(d, dict({"one": 1}, two=2)) - vereq(d, dict([("two", 2)], one=1)) - vereq(d, dict([("one", 100), ("two", 200)], **d)) - verify(d is not dict(**d)) - for badarg in 0, 0, 0j, "0", [0], (0,): + def set2op_test(self, a, b, c, res, stmt="a[b]=c", meth="__setitem__"): + d = {'a': deepcopy(a), 'b': b, 'c': c} + exec(stmt, d) + self.assertEqual(d['a'], res) + t = type(a) + m = getattr(t, meth) + while meth not in t.__dict__: + t = t.__bases__[0] + self.assertEqual(m, t.__dict__[meth]) + d['a'] = deepcopy(a) + m(d['a'], b, c) + self.assertEqual(d['a'], res) + d['a'] = deepcopy(a) + bm = getattr(d['a'], meth) + bm(b, c) + self.assertEqual(d['a'], res) + + def setsliceop_test(self, a, b, c, d, res, stmt="a[b:c]=d", meth="__setitem__"): + dictionary = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d} + exec(stmt, dictionary) + self.assertEqual(dictionary['a'], res) + t = type(a) + while meth not in t.__dict__: + t = t.__bases__[0] + m = getattr(t, meth) + self.assertEqual(m, t.__dict__[meth]) + dictionary['a'] = deepcopy(a) + m(dictionary['a'], slice(b, c), d) + self.assertEqual(dictionary['a'], res) + dictionary['a'] = deepcopy(a) + bm = getattr(dictionary['a'], meth) + bm(slice(b, c), d) + self.assertEqual(dictionary['a'], res) + + def test_lists(self): + # Testing list operations... + # Asserts are within individual test methods + self.binop_test([1], [2], [1,2], "a+b", "__add__") + self.binop_test([1,2,3], 2, 1, "b in a", "__contains__") + self.binop_test([1,2,3], 4, 0, "b in a", "__contains__") + self.binop_test([1,2,3], 1, 2, "a[b]", "__getitem__") + self.sliceop_test([1,2,3], 0, 2, [1,2], "a[b:c]", "__getitem__") + self.setop_test([1], [2], [1,2], "a+=b", "__iadd__") + self.setop_test([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__") + self.unop_test([1,2,3], 3, "len(a)", "__len__") + self.binop_test([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__") + self.binop_test([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__") + self.set2op_test([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__") + self.setsliceop_test([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", + "__setitem__") + + def test_dicts(self): + # Testing dict operations... + ## self.binop_test({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__") + self.binop_test({1:2,3:4}, 1, 1, "b in a", "__contains__") + self.binop_test({1:2,3:4}, 2, 0, "b in a", "__contains__") + self.binop_test({1:2,3:4}, 1, 2, "a[b]", "__getitem__") + + d = {1:2, 3:4} + l1 = [] + for i in list(d.keys()): + l1.append(i) + l = [] + for i in iter(d): + l.append(i) + self.assertEqual(l, l1) + l = [] + for i in d.__iter__(): + l.append(i) + self.assertEqual(l, l1) + l = [] + for i in dict.__iter__(d): + l.append(i) + self.assertEqual(l, l1) + d = {1:2, 3:4} + self.unop_test(d, 2, "len(a)", "__len__") + self.assertEqual(eval(repr(d), {}), d) + self.assertEqual(eval(d.__repr__(), {}), d) + self.set2op_test({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c", + "__setitem__") + + # Tests for unary and binary operators + def number_operators(self, a, b, skip=[]): + dict = {'a': a, 'b': b} + + for name, expr in list(self.binops.items()): + if name not in skip: + name = "__%s__" % name + if hasattr(a, name): + res = eval(expr, dict) + self.binop_test(a, b, res, expr, name) + + for name, expr in list(self.unops.items()): + if name not in skip: + name = "__%s__" % name + if hasattr(a, name): + res = eval(expr, dict) + self.unop_test(a, res, expr, name) + + def test_ints(self): + # Testing int operations... + self.number_operators(100, 3) + # The following crashes in Python 2.2 + self.assertEqual((1).__bool__(), 1) + self.assertEqual((0).__bool__(), 0) + # This returns 'NotImplemented' in Python 2.2 + class C(int): + def __add__(self, other): + return NotImplemented + self.assertEqual(C(5), 5) try: - dict(badarg) + C() + "" except TypeError: pass - except ValueError: - if badarg == "0": - # It's a sequence, and its elements are also sequences (gotta - # love strings ), but they aren't of length 2, so this - # one seemed better as a ValueError than a TypeError. - pass - else: - raise TestFailed("no TypeError from dict(%r)" % badarg) else: - raise TestFailed("no TypeError from dict(%r)" % badarg) + self.fail("NotImplemented should have caused TypeError") - try: - dict({}, {}) - except TypeError: - pass - else: - raise TestFailed("no TypeError from dict({}, {})") + def test_longs(self): + # Testing long operations... + self.number_operators(100, 3) - class Mapping: - # Lacks a .keys() method; will be added later. - dict = {1:2, 3:4, 'a':1j} + def test_floats(self): + # Testing float operations... + self.number_operators(100.0, 3.0) - try: - dict(Mapping()) - except TypeError: - pass - else: - raise TestFailed("no TypeError from dict(incomplete mapping)") + def test_complexes(self): + # Testing complex operations... + self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge', + 'int', 'long', 'float', + 'divmod', 'mod']) - Mapping.keys = lambda self: self.dict.keys() - Mapping.__getitem__ = lambda self, i: self.dict[i] - d = dict(Mapping()) - vereq(d, Mapping.dict) + class Number(complex): + __slots__ = ['prec'] + def __new__(cls, *args, **kwds): + result = complex.__new__(cls, *args) + result.prec = kwds.get('prec', 12) + return result + def __repr__(self): + prec = self.prec + if self.imag == 0.0: + return "%.*g" % (prec, self.real) + if self.real == 0.0: + return "%.*gj" % (prec, self.imag) + return "(%.*g+%.*gj)" % (prec, self.real, prec, self.imag) + __str__ = __repr__ - # Init from sequence of iterable objects, each producing a 2-sequence. - class AddressBookEntry: - def __init__(self, first, last): - self.first = first - self.last = last - def __iter__(self): - return iter([self.first, self.last]) + a = Number(3.14, prec=6) + self.assertEqual(repr(a), "3.14") + self.assertEqual(a.prec, 6) - d = dict([AddressBookEntry('Tim', 'Warsaw'), - AddressBookEntry('Barry', 'Peters'), - AddressBookEntry('Tim', 'Peters'), - AddressBookEntry('Barry', 'Warsaw')]) - vereq(d, {'Barry': 'Warsaw', 'Tim': 'Peters'}) + a = Number(a, prec=2) + self.assertEqual(repr(a), "3.1") + self.assertEqual(a.prec, 2) - d = dict(zip(range(4), range(1, 5))) - vereq(d, dict([(i, i+1) for i in range(4)])) + a = Number(234.5) + self.assertEqual(repr(a), "234.5") + self.assertEqual(a.prec, 12) - # Bad sequence lengths. - for bad in [('tooshort',)], [('too', 'long', 'by 1')]: + def test_spam_lists(self): + # Testing spamlist operations... + import copy, xxsubtype as spam + + def spamlist(l, memo=None): + import xxsubtype as spam + return spam.spamlist(l) + + # This is an ugly hack: + copy._deepcopy_dispatch[spam.spamlist] = spamlist + + self.binop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b", + "__add__") + self.binop_test(spamlist([1,2,3]), 2, 1, "b in a", "__contains__") + self.binop_test(spamlist([1,2,3]), 4, 0, "b in a", "__contains__") + self.binop_test(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__") + self.sliceop_test(spamlist([1,2,3]), 0, 2, spamlist([1,2]), "a[b:c]", + "__getitem__") + self.setop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+=b", + "__iadd__") + self.setop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", + "__imul__") + self.unop_test(spamlist([1,2,3]), 3, "len(a)", "__len__") + self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", + "__mul__") + self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", + "__rmul__") + self.set2op_test(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", + "__setitem__") + self.setsliceop_test(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]), + spamlist([1,5,6,4]), "a[b:c]=d", "__setitem__") + # Test subclassing + class C(spam.spamlist): + def foo(self): return 1 + a = C() + self.assertEqual(a, []) + self.assertEqual(a.foo(), 1) + a.append(100) + self.assertEqual(a, [100]) + self.assertEqual(a.getstate(), 0) + a.setstate(42) + self.assertEqual(a.getstate(), 42) + + def test_spam_dicts(self): + # Testing spamdict operations... + import copy, xxsubtype as spam + def spamdict(d, memo=None): + import xxsubtype as spam + sd = spam.spamdict() + for k, v in list(d.items()): + sd[k] = v + return sd + # This is an ugly hack: + copy._deepcopy_dispatch[spam.spamdict] = spamdict + + ## self.binop_test(spamdict({1:2}), spamdict({2:1}), -1, "cmp(a,b)", + ## "__cmp__") + self.binop_test(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__") + self.binop_test(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__") + self.binop_test(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__") + d = spamdict({1:2,3:4}) + l1 = [] + for i in list(d.keys()): + l1.append(i) + l = [] + for i in iter(d): + l.append(i) + self.assertEqual(l, l1) + l = [] + for i in d.__iter__(): + l.append(i) + self.assertEqual(l, l1) + l = [] + for i in type(spamdict({})).__iter__(d): + l.append(i) + self.assertEqual(l, l1) + straightd = {1:2, 3:4} + spamd = spamdict(straightd) + self.unop_test(spamd, 2, "len(a)", "__len__") + self.unop_test(spamd, repr(straightd), "repr(a)", "__repr__") + self.set2op_test(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}), + "a[b]=c", "__setitem__") + # Test subclassing + class C(spam.spamdict): + def foo(self): return 1 + a = C() + self.assertEqual(list(a.items()), []) + self.assertEqual(a.foo(), 1) + a['foo'] = 'bar' + self.assertEqual(list(a.items()), [('foo', 'bar')]) + self.assertEqual(a.getstate(), 0) + a.setstate(100) + self.assertEqual(a.getstate(), 100) + +class ClassPropertiesAndMethods(unittest.TestCase): + + def test_python_dicts(self): + # Testing Python subclass of dict... + self.assert_(issubclass(dict, dict)) + self.assert_(isinstance({}, dict)) + d = dict() + self.assertEqual(d, {}) + self.assert_(d.__class__ is dict) + self.assert_(isinstance(d, dict)) + class C(dict): + state = -1 + def __init__(self_local, *a, **kw): + if a: + self.assertEqual(len(a), 1) + self_local.state = a[0] + if kw: + for k, v in list(kw.items()): + self_local[v] = k + def __getitem__(self, key): + return self.get(key, 0) + def __setitem__(self_local, key, value): + self.assert_(isinstance(key, type(0))) + dict.__setitem__(self_local, key, value) + def setstate(self, state): + self.state = state + def getstate(self): + return self.state + self.assert_(issubclass(C, dict)) + a1 = C(12) + self.assertEqual(a1.state, 12) + a2 = C(foo=1, bar=2) + self.assertEqual(a2[1] == 'foo' and a2[2], 'bar') + a = C() + self.assertEqual(a.state, -1) + self.assertEqual(a.getstate(), -1) + a.setstate(0) + self.assertEqual(a.state, 0) + self.assertEqual(a.getstate(), 0) + a.setstate(10) + self.assertEqual(a.state, 10) + self.assertEqual(a.getstate(), 10) + self.assertEqual(a[42], 0) + a[42] = 24 + self.assertEqual(a[42], 24) + N = 50 + for i in range(N): + a[i] = C() + for j in range(N): + a[i][j] = i*j + for i in range(N): + for j in range(N): + self.assertEqual(a[i][j], i*j) + + def test_python_lists(self): + # Testing Python subclass of list... + class C(list): + def __getitem__(self, i): + if isinstance(i, slice): + return i.start, i.stop + return list.__getitem__(self, i) + 100 + a = C() + a.extend([0,1,2]) + self.assertEqual(a[0], 100) + self.assertEqual(a[1], 101) + self.assertEqual(a[2], 102) + self.assertEqual(a[100:200], (100,200)) + + def test_metaclass(self): + # Testing __metaclass__... + class C(metaclass=type): + def __init__(self): + self.__state = 0 + def getstate(self): + return self.__state + def setstate(self, state): + self.__state = state + a = C() + self.assertEqual(a.getstate(), 0) + a.setstate(10) + self.assertEqual(a.getstate(), 10) + class _metaclass(type): + def myself(cls): return cls + class D(metaclass=_metaclass): + pass + self.assertEqual(D.myself(), D) + d = D() + self.assertEqual(d.__class__, D) + class M1(type): + def __new__(cls, name, bases, dict): + dict['__spam__'] = 1 + return type.__new__(cls, name, bases, dict) + class C(metaclass=M1): + pass + self.assertEqual(C.__spam__, 1) + c = C() + self.assertEqual(c.__spam__, 1) + + class _instance(object): + pass + class M2(object): + @staticmethod + def __new__(cls, name, bases, dict): + self = object.__new__(cls) + self.name = name + self.bases = bases + self.dict = dict + return self + def __call__(self): + it = _instance() + # Early binding of methods + for key in self.dict: + if key.startswith("__"): + continue + setattr(it, key, self.dict[key].__get__(it, self)) + return it + class C(metaclass=M2): + def spam(self): + return 42 + self.assertEqual(C.name, 'C') + self.assertEqual(C.bases, ()) + self.assert_('spam' in C.dict) + c = C() + self.assertEqual(c.spam(), 42) + + # More metaclass examples + + class autosuper(type): + # Automatically add __super to the class + # This trick only works for dynamic classes + def __new__(metaclass, name, bases, dict): + cls = super(autosuper, metaclass).__new__(metaclass, + name, bases, dict) + # Name mangling for __super removes leading underscores + while name[:1] == "_": + name = name[1:] + if name: + name = "_%s__super" % name + else: + name = "__super" + setattr(cls, name, super(cls)) + return cls + class A(metaclass=autosuper): + def meth(self): + return "A" + class B(A): + def meth(self): + return "B" + self.__super.meth() + class C(A): + def meth(self): + return "C" + self.__super.meth() + class D(C, B): + def meth(self): + return "D" + self.__super.meth() + self.assertEqual(D().meth(), "DCBA") + class E(B, C): + def meth(self): + return "E" + self.__super.meth() + self.assertEqual(E().meth(), "EBCA") + + class autoproperty(type): + # Automatically create property attributes when methods + # named _get_x and/or _set_x are found + def __new__(metaclass, name, bases, dict): + hits = {} + for key, val in dict.items(): + if key.startswith("_get_"): + key = key[5:] + get, set = hits.get(key, (None, None)) + get = val + hits[key] = get, set + elif key.startswith("_set_"): + key = key[5:] + get, set = hits.get(key, (None, None)) + set = val + hits[key] = get, set + for key, (get, set) in hits.items(): + dict[key] = property(get, set) + return super(autoproperty, metaclass).__new__(metaclass, + name, bases, dict) + class A(metaclass=autoproperty): + def _get_x(self): + return -self.__x + def _set_x(self, x): + self.__x = -x + a = A() + self.assert_(not hasattr(a, "x")) + a.x = 12 + self.assertEqual(a.x, 12) + self.assertEqual(a._A__x, -12) + + class multimetaclass(autoproperty, autosuper): + # Merge of multiple cooperating metaclasses + pass + class A(metaclass=multimetaclass): + def _get_x(self): + return "A" + class B(A): + def _get_x(self): + return "B" + self.__super._get_x() + class C(A): + def _get_x(self): + return "C" + self.__super._get_x() + class D(C, B): + def _get_x(self): + return "D" + self.__super._get_x() + self.assertEqual(D().x, "DCBA") + + # Make sure type(x) doesn't call x.__class__.__init__ + class T(type): + counter = 0 + def __init__(self, *args): + T.counter += 1 + class C(metaclass=T): + pass + self.assertEqual(T.counter, 1) + a = C() + self.assertEqual(type(a), C) + self.assertEqual(T.counter, 1) + + class C(object): pass + c = C() + try: c() + except TypeError: pass + else: self.fail("calling object w/o call method should raise " + "TypeError") + + # Testing code to find most derived baseclass + class A(type): + def __new__(*args, **kwargs): + return type.__new__(*args, **kwargs) + + class B(object): + pass + + class C(object, metaclass=A): + pass + + # The most derived metaclass of D is A rather than type. + class D(B, C): + pass + + def test_module_subclasses(self): + # Testing Python subclass of module... + log = [] + import types, sys + MT = type(sys) + class MM(MT): + def __init__(self, name): + MT.__init__(self, name) + def __getattribute__(self, name): + log.append(("getattr", name)) + return MT.__getattribute__(self, name) + def __setattr__(self, name, value): + log.append(("setattr", name, value)) + MT.__setattr__(self, name, value) + def __delattr__(self, name): + log.append(("delattr", name)) + MT.__delattr__(self, name) + a = MM("a") + a.foo = 12 + x = a.foo + del a.foo + self.assertEqual(log, [("setattr", "foo", 12), + ("getattr", "foo"), + ("delattr", "foo")]) + + # http://python.org/sf/1174712 try: - dict(bad) - except ValueError: + class Module(types.ModuleType, str): + pass + except TypeError: pass else: - raise TestFailed("no ValueError from dict(%r)" % bad) + self.fail("inheriting from ModuleType and str at the same time " + "should fail") -def test_dir(): - if verbose: - print("Testing dir() ...") - junk = 12 - vereq(dir(), ['junk']) - del junk + def test_multiple_inheritance(self): + # Testing multiple inheritance... + class C(object): + def __init__(self): + self.__state = 0 + def getstate(self): + return self.__state + def setstate(self, state): + self.__state = state + a = C() + self.assertEqual(a.getstate(), 0) + a.setstate(10) + self.assertEqual(a.getstate(), 10) + class D(dict, C): + def __init__(self): + type({}).__init__(self) + C.__init__(self) + d = D() + self.assertEqual(list(d.keys()), []) + d["hello"] = "world" + self.assertEqual(list(d.items()), [("hello", "world")]) + self.assertEqual(d["hello"], "world") + self.assertEqual(d.getstate(), 0) + d.setstate(10) + self.assertEqual(d.getstate(), 10) + self.assertEqual(D.__mro__, (D, dict, C, object)) - # Just make sure these don't blow up! - for arg in 2, 2, 2j, 2e0, [2], "2", b"2", (2,), {2:2}, type, test_dir: - dir(arg) + # SF bug #442833 + class Node(object): + def __int__(self): + return int(self.foo()) + def foo(self): + return "23" + class Frag(Node, list): + def foo(self): + return "42" + self.assertEqual(Node().__int__(), 23) + self.assertEqual(int(Node()), 23) + self.assertEqual(Frag().__int__(), 42) + self.assertEqual(int(Frag()), 42) - # Test dir on custom classes. Since these have object as a - # base class, a lot of stuff gets sucked in. - def interesting(strings): - return [s for s in strings if not s.startswith('_')] - - class C(object): - Cdata = 1 - def Cmethod(self): pass - - cstuff = ['Cdata', 'Cmethod'] - vereq(interesting(dir(C)), cstuff) - - c = C() - vereq(interesting(dir(c)), cstuff) - #verify('__self__' in dir(C.Cmethod)) - - c.cdata = 2 - c.cmethod = lambda self: 0 - vereq(interesting(dir(c)), cstuff + ['cdata', 'cmethod']) - #verify('__self__' in dir(c.Cmethod)) - - class A(C): - Adata = 1 - def Amethod(self): pass - - astuff = ['Adata', 'Amethod'] + cstuff - vereq(interesting(dir(A)), astuff) - #verify('__self__' in dir(A.Amethod)) - a = A() - vereq(interesting(dir(a)), astuff) - a.adata = 42 - a.amethod = lambda self: 3 - vereq(interesting(dir(a)), astuff + ['adata', 'amethod']) - #verify('__self__' in dir(a.Amethod)) - - # Try a module subclass. - import sys - class M(type(sys)): - pass - minstance = M("m") - minstance.b = 2 - minstance.a = 1 - names = [x for x in dir(minstance) if x not in ["__name__", "__doc__"]] - vereq(names, ['a', 'b']) - - class M2(M): - def getdict(self): - return "Not a dict!" - __dict__ = property(getdict) - - m2instance = M2("m2") - m2instance.b = 2 - m2instance.a = 1 - vereq(m2instance.__dict__, "Not a dict!") - try: - dir(m2instance) - except TypeError: - pass - - # Two essentially featureless objects, just inheriting stuff from - # object. - vereq(dir(None), dir(Ellipsis)) - - # Nasty test case for proxied objects - class Wrapper(object): - def __init__(self, obj): - self.__obj = obj - def __repr__(self): - return "Wrapper(%s)" % repr(self.__obj) - def __getitem__(self, key): - return Wrapper(self.__obj[key]) - def __len__(self): - return len(self.__obj) - def __getattr__(self, name): - return Wrapper(getattr(self.__obj, name)) - - class C(object): - def __getclass(self): - return Wrapper(type(self)) - __class__ = property(__getclass) - - dir(C()) # This used to segfault - -binops = { - 'add': '+', - 'sub': '-', - 'mul': '*', - 'div': '/', - 'mod': '%', - 'divmod': 'divmod', - 'pow': '**', - 'lshift': '<<', - 'rshift': '>>', - 'and': '&', - 'xor': '^', - 'or': '|', - 'cmp': 'cmp', - 'lt': '<', - 'le': '<=', - 'eq': '==', - 'ne': '!=', - 'gt': '>', - 'ge': '>=', - } - -for name, expr in binops.items(): - if expr.islower(): - expr = expr + "(a, b)" - else: - expr = 'a %s b' % expr - binops[name] = expr - -unops = { - 'pos': '+', - 'neg': '-', - 'abs': 'abs', - 'invert': '~', - 'int': 'int', - 'float': 'float', - 'oct': 'oct', - 'hex': 'hex', - } - -for name, expr in unops.items(): - if expr.islower(): - expr = expr + "(a)" - else: - expr = '%s a' % expr - unops[name] = expr - -def numops(a, b, skip=[]): - dict = {'a': a, 'b': b} - for name, expr in binops.items(): - if name not in skip: - name = "__%s__" % name - if hasattr(a, name): - res = eval(expr, dict) - testbinop(a, b, res, expr, name) - for name, expr in unops.items(): - if name not in skip: - name = "__%s__" % name - if hasattr(a, name): - res = eval(expr, dict) - testunop(a, res, expr, name) - -def ints(): - if verbose: print("Testing int operations...") - numops(100, 3) - # The following crashes in Python 2.2 - vereq((1).__bool__(), True) - vereq((0).__bool__(), False) - # This returns 'NotImplemented' in Python 2.2 - class C(int): - def __add__(self, other): - return NotImplemented - vereq(C(5), 5) - try: - C() + "" - except TypeError: - pass - else: - raise TestFailed("NotImplemented should have caused TypeError") - -def longs(): - if verbose: print("Testing long operations...") - numops(100, 3) - -def floats(): - if verbose: print("Testing float operations...") - numops(100.0, 3.0) - -def complexes(): - if verbose: print("Testing complex operations...") - numops(100.0j, 3.0j, - skip=['lt', 'le', 'gt', 'ge', 'int', 'long', 'float', - 'divmod', 'mod']) - class Number(complex): - __slots__ = ['prec'] - def __new__(cls, *args, **kwds): - result = complex.__new__(cls, *args) - result.prec = kwds.get('prec', 12) - return result - def __repr__(self): - prec = self.prec - if self.imag == 0.0: - return "%.*g" % (prec, self.real) - if self.real == 0.0: - return "%.*gj" % (prec, self.imag) - return "(%.*g+%.*gj)" % (prec, self.real, prec, self.imag) - __str__ = __repr__ - - a = Number(3.14, prec=6) - vereq(repr(a), "3.14") - vereq(a.prec, 6) - - a = Number(a, prec=2) - vereq(repr(a), "3.1") - vereq(a.prec, 2) - - a = Number(234.5) - vereq(repr(a), "234.5") - vereq(a.prec, 12) - -def spamlists(): - if verbose: print("Testing spamlist operations...") - import copy, xxsubtype as spam - def spamlist(l, memo=None): - import xxsubtype as spam - return spam.spamlist(l) - # This is an ugly hack: - copy._deepcopy_dispatch[spam.spamlist] = spamlist - - testbinop(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b", "__add__") - testbinop(spamlist([1,2,3]), 2, 1, "b in a", "__contains__") - testbinop(spamlist([1,2,3]), 4, 0, "b in a", "__contains__") - testbinop(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__") - testsliceop(spamlist([1,2,3]), 0, 2, spamlist([1,2]), - "a[b:c]", "__getitem__") - testsetop(spamlist([1]), spamlist([2]), spamlist([1,2]), - "a+=b", "__iadd__") - testsetop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", "__imul__") - testunop(spamlist([1,2,3]), 3, "len(a)", "__len__") - testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", "__mul__") - testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", "__rmul__") - testset2op(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", "__setitem__") - testsetsliceop(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]), - spamlist([1,5,6,4]), "a[b:c]=d", "__setitem__") - # Test subclassing - class C(spam.spamlist): - def foo(self): return 1 - a = C() - vereq(a, []) - vereq(a.foo(), 1) - a.append(100) - vereq(a, [100]) - vereq(a.getstate(), 0) - a.setstate(42) - vereq(a.getstate(), 42) - -def spamdicts(): - if verbose: print("Testing spamdict operations...") - import copy, xxsubtype as spam - def spamdict(d, memo=None): - import xxsubtype as spam - sd = spam.spamdict() - for k, v in d.items(): sd[k] = v - return sd - # This is an ugly hack: - copy._deepcopy_dispatch[spam.spamdict] = spamdict - - ##testbinop(spamdict({1:2}), spamdict({2:1}), -1, "cmp(a,b)", "__cmp__") - testbinop(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__") - testbinop(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__") - testbinop(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__") - d = spamdict({1:2,3:4}) - l1 = [] - for i in d.keys(): l1.append(i) - l = [] - for i in iter(d): l.append(i) - vereq(l, l1) - l = [] - for i in d.__iter__(): l.append(i) - vereq(l, l1) - l = [] - for i in type(spamdict({})).__iter__(d): l.append(i) - vereq(l, l1) - straightd = {1:2, 3:4} - spamd = spamdict(straightd) - testunop(spamd, 2, "len(a)", "__len__") - testunop(spamd, repr(straightd), "repr(a)", "__repr__") - testset2op(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}), - "a[b]=c", "__setitem__") - # Test subclassing - class C(spam.spamdict): - def foo(self): return 1 - a = C() - vereq(list(a.items()), []) - vereq(a.foo(), 1) - a['foo'] = 'bar' - vereq(list(a.items()), [('foo', 'bar')]) - vereq(a.getstate(), 0) - a.setstate(100) - vereq(a.getstate(), 100) - -def pydicts(): - if verbose: print("Testing Python subclass of dict...") - verify(issubclass(dict, dict)) - verify(isinstance({}, dict)) - d = dict() - vereq(d, {}) - verify(d.__class__ is dict) - verify(isinstance(d, dict)) - class C(dict): - state = -1 - def __init__(self, *a, **kw): - if a: - vereq(len(a), 1) - self.state = a[0] - if kw: - for k, v in kw.items(): self[v] = k - def __getitem__(self, key): - return self.get(key, 0) - def __setitem__(self, key, value): - verify(isinstance(key, type(0))) - dict.__setitem__(self, key, value) - def setstate(self, state): - self.state = state - def getstate(self): - return self.state - verify(issubclass(C, dict)) - a1 = C(12) - vereq(a1.state, 12) - a2 = C(foo=1, bar=2) - vereq(a2[1] == 'foo' and a2[2], 'bar') - a = C() - vereq(a.state, -1) - vereq(a.getstate(), -1) - a.setstate(0) - vereq(a.state, 0) - vereq(a.getstate(), 0) - a.setstate(10) - vereq(a.state, 10) - vereq(a.getstate(), 10) - vereq(a[42], 0) - a[42] = 24 - vereq(a[42], 24) - if verbose: print("pydict stress test ...") - N = 50 - for i in range(N): - a[i] = C() - for j in range(N): - a[i][j] = i*j - for i in range(N): - for j in range(N): - vereq(a[i][j], i*j) - -def pylists(): - if verbose: print("Testing Python subclass of list...") - class C(list): - def __getitem__(self, i): - if isinstance(i, slice): - return (i.start, i.stop) - return list.__getitem__(self, i) + 100 - a = C() - a.extend([0,1,2]) - vereq(a[0], 100) - vereq(a[1], 101) - vereq(a[2], 102) - vereq(a[100:200], (100,200)) - -def metaclass(): - if verbose: print("Testing metaclass...") - class C(metaclass=type): - def __init__(self): - self.__state = 0 - def getstate(self): - return self.__state - def setstate(self, state): - self.__state = state - a = C() - vereq(a.getstate(), 0) - a.setstate(10) - vereq(a.getstate(), 10) - class _metaclass(type): - def myself(cls): return cls - class D(metaclass=_metaclass): - pass - vereq(D.myself(), D) - d = D() - verify(d.__class__ is D) - class M1(type): - def __new__(cls, name, bases, dict): - dict['__spam__'] = 1 - return type.__new__(cls, name, bases, dict) - class C(metaclass=M1): - pass - vereq(C.__spam__, 1) - c = C() - vereq(c.__spam__, 1) - - class _instance(object): - pass - class M2(object): - @staticmethod - def __new__(cls, name, bases, dict): - self = object.__new__(cls) - self.name = name - self.bases = bases - self.dict = dict - return self - def __call__(self): - it = _instance() - # Early binding of methods - for key in self.dict: - if key.startswith("__"): - continue - setattr(it, key, self.dict[key].__get__(it, self)) - return it - class C(metaclass=M2): - def spam(self): - return 42 - vereq(C.name, 'C') - vereq(C.bases, ()) - verify('spam' in C.dict) - c = C() - vereq(c.spam(), 42) - - # More metaclass examples - - class autosuper(type): - # Automatically add __super to the class - # This trick only works for dynamic classes - def __new__(metaclass, name, bases, dict): - cls = super(autosuper, metaclass).__new__(metaclass, - name, bases, dict) - # Name mangling for __super removes leading underscores - while name[:1] == "_": - name = name[1:] - if name: - name = "_%s__super" % name - else: - name = "__super" - setattr(cls, name, super(cls)) - return cls - class A(metaclass=autosuper): - def meth(self): - return "A" - class B(A): - def meth(self): - return "B" + self.__super.meth() - class C(A): - def meth(self): - return "C" + self.__super.meth() - class D(C, B): - def meth(self): - return "D" + self.__super.meth() - vereq(D().meth(), "DCBA") - class E(B, C): - def meth(self): - return "E" + self.__super.meth() - vereq(E().meth(), "EBCA") - - class autoproperty(type): - # Automatically create property attributes when methods - # named _get_x and/or _set_x are found - def __new__(metaclass, name, bases, dict): - hits = {} - for key, val in dict.items(): - if key.startswith("_get_"): - key = key[5:] - get, set = hits.get(key, (None, None)) - get = val - hits[key] = get, set - elif key.startswith("_set_"): - key = key[5:] - get, set = hits.get(key, (None, None)) - set = val - hits[key] = get, set - for key, (get, set) in hits.items(): - dict[key] = property(get, set) - return super(autoproperty, metaclass).__new__(metaclass, - name, bases, dict) - class A(metaclass=autoproperty): - def _get_x(self): - return -self.__x - def _set_x(self, x): - self.__x = -x - a = A() - verify(not hasattr(a, "x")) - a.x = 12 - vereq(a.x, 12) - vereq(a._A__x, -12) - - class multimetaclass(autoproperty, autosuper): - # Merge of multiple cooperating metaclasses - pass - class A(metaclass=multimetaclass): - def _get_x(self): - return "A" - class B(A): - def _get_x(self): - return "B" + self.__super._get_x() - class C(A): - def _get_x(self): - return "C" + self.__super._get_x() - class D(C, B): - def _get_x(self): - return "D" + self.__super._get_x() - vereq(D().x, "DCBA") - - # Make sure type(x) doesn't call x.__class__.__init__ - class T(type): - counter = 0 - def __init__(self, *args): - T.counter += 1 - class C(metaclass=T): - pass - vereq(T.counter, 1) - a = C() - vereq(type(a), C) - vereq(T.counter, 1) - - class C(object): pass - c = C() - try: c() - except TypeError: pass - else: raise TestFailed("calling object w/o call method should raise TypeError") - - # Testing code to find most derived baseclass - class A(type): - def __new__(*args, **kwargs): - return type.__new__(*args, **kwargs) - - class B(object): - pass - - class C(object, metaclass=A): - pass - - # The most derived metaclass of D is A rather than type. - class D(B, C): - pass - - -def pymods(): - if verbose: print("Testing Python subclass of module...") - log = [] - import sys - MT = type(sys) - class MM(MT): - def __init__(self, name): - MT.__init__(self, name) - def __getattribute__(self, name): - log.append(("getattr", name)) - return MT.__getattribute__(self, name) - def __setattr__(self, name, value): - log.append(("setattr", name, value)) - MT.__setattr__(self, name, value) - def __delattr__(self, name): - log.append(("delattr", name)) - MT.__delattr__(self, name) - a = MM("a") - a.foo = 12 - x = a.foo - del a.foo - vereq(log, [("setattr", "foo", 12), - ("getattr", "foo"), - ("delattr", "foo")]) - - # http://python.org/sf/1174712 - try: - class Module(types.ModuleType, str): + def test_diamond_inheritence(self): + # Testing multiple inheritance special cases... + class A(object): + def spam(self): return "A" + self.assertEqual(A().spam(), "A") + class B(A): + def boo(self): return "B" + def spam(self): return "B" + self.assertEqual(B().spam(), "B") + self.assertEqual(B().boo(), "B") + class C(A): + def boo(self): return "C" + self.assertEqual(C().spam(), "A") + self.assertEqual(C().boo(), "C") + class D(B, C): pass + self.assertEqual(D().spam(), "B") + self.assertEqual(D().boo(), "B") + self.assertEqual(D.__mro__, (D, B, C, A, object)) + class E(C, B): pass + self.assertEqual(E().spam(), "B") + self.assertEqual(E().boo(), "C") + self.assertEqual(E.__mro__, (E, C, B, A, object)) + # MRO order disagreement + try: + class F(D, E): pass + except TypeError: pass - except TypeError: - pass - else: - raise TestFailed("inheriting from ModuleType and str at the " - "same time should fail") + else: + self.fail("expected MRO order disagreement (F)") + try: + class G(E, D): pass + except TypeError: + pass + else: + self.fail("expected MRO order disagreement (G)") -def multi(): - if verbose: print("Testing multiple inheritance...") - class C(object): - def __init__(self): - self.__state = 0 - def getstate(self): - return self.__state - def setstate(self, state): - self.__state = state - a = C() - vereq(a.getstate(), 0) - a.setstate(10) - vereq(a.getstate(), 10) - class D(dict, C): - def __init__(self): - type({}).__init__(self) - C.__init__(self) - d = D() - vereq(list(d.keys()), []) - d["hello"] = "world" - vereq(list(d.items()), [("hello", "world")]) - vereq(d["hello"], "world") - vereq(d.getstate(), 0) - d.setstate(10) - vereq(d.getstate(), 10) - vereq(D.__mro__, (D, dict, C, object)) + # see thread python-dev/2002-October/029035.html + def test_ex5_from_c3_switch(self): + # Testing ex5 from C3 switch discussion... + class A(object): pass + class B(object): pass + class C(object): pass + class X(A): pass + class Y(A): pass + class Z(X,B,Y,C): pass + self.assertEqual(Z.__mro__, (Z, X, B, Y, A, C, object)) - # SF bug #442833 - class Node(object): - def __int__(self): - return int(self.foo()) - def foo(self): - return "23" - class Frag(Node, list): - def foo(self): - return "42" - vereq(Node().__int__(), 23) - vereq(int(Node()), 23) - vereq(Frag().__int__(), 42) - vereq(int(Frag()), 42) + # see "A Monotonic Superclass Linearization for Dylan", + # by Kim Barrett et al. (OOPSLA 1996) + def test_monotonicity(self): + # Testing MRO monotonicity... + class Boat(object): pass + class DayBoat(Boat): pass + class WheelBoat(Boat): pass + class EngineLess(DayBoat): pass + class SmallMultihull(DayBoat): pass + class PedalWheelBoat(EngineLess,WheelBoat): pass + class SmallCatamaran(SmallMultihull): pass + class Pedalo(PedalWheelBoat,SmallCatamaran): pass -def diamond(): - if verbose: print("Testing multiple inheritance special cases...") - class A(object): - def spam(self): return "A" - vereq(A().spam(), "A") - class B(A): - def boo(self): return "B" - def spam(self): return "B" - vereq(B().spam(), "B") - vereq(B().boo(), "B") - class C(A): - def boo(self): return "C" - vereq(C().spam(), "A") - vereq(C().boo(), "C") - class D(B, C): pass - vereq(D().spam(), "B") - vereq(D().boo(), "B") - vereq(D.__mro__, (D, B, C, A, object)) - class E(C, B): pass - vereq(E().spam(), "B") - vereq(E().boo(), "C") - vereq(E.__mro__, (E, C, B, A, object)) - # MRO order disagreement - try: - class F(D, E): pass - except TypeError: - pass - else: - raise TestFailed("expected MRO order disagreement (F)") - try: - class G(E, D): pass - except TypeError: - pass - else: - raise TestFailed("expected MRO order disagreement (G)") + self.assertEqual(PedalWheelBoat.__mro__, + (PedalWheelBoat, EngineLess, DayBoat, WheelBoat, Boat, object)) + self.assertEqual(SmallCatamaran.__mro__, + (SmallCatamaran, SmallMultihull, DayBoat, Boat, object)) + self.assertEqual(Pedalo.__mro__, + (Pedalo, PedalWheelBoat, EngineLess, SmallCatamaran, + SmallMultihull, DayBoat, WheelBoat, Boat, object)) + # see "A Monotonic Superclass Linearization for Dylan", + # by Kim Barrett et al. (OOPSLA 1996) + def test_consistency_with_epg(self): + # Testing consistentcy with EPG... + class Pane(object): pass + class ScrollingMixin(object): pass + class EditingMixin(object): pass + class ScrollablePane(Pane,ScrollingMixin): pass + class EditablePane(Pane,EditingMixin): pass + class EditableScrollablePane(ScrollablePane,EditablePane): pass -# see thread python-dev/2002-October/029035.html -def ex5(): - if verbose: print("Testing ex5 from C3 switch discussion...") - class A(object): pass - class B(object): pass - class C(object): pass - class X(A): pass - class Y(A): pass - class Z(X,B,Y,C): pass - vereq(Z.__mro__, (Z, X, B, Y, A, C, object)) + self.assertEqual(EditableScrollablePane.__mro__, + (EditableScrollablePane, ScrollablePane, EditablePane, Pane, + ScrollingMixin, EditingMixin, object)) -# see "A Monotonic Superclass Linearization for Dylan", -# by Kim Barrett et al. (OOPSLA 1996) -def monotonicity(): - if verbose: print("Testing MRO monotonicity...") - class Boat(object): pass - class DayBoat(Boat): pass - class WheelBoat(Boat): pass - class EngineLess(DayBoat): pass - class SmallMultihull(DayBoat): pass - class PedalWheelBoat(EngineLess,WheelBoat): pass - class SmallCatamaran(SmallMultihull): pass - class Pedalo(PedalWheelBoat,SmallCatamaran): pass - - vereq(PedalWheelBoat.__mro__, - (PedalWheelBoat, EngineLess, DayBoat, WheelBoat, Boat, - object)) - vereq(SmallCatamaran.__mro__, - (SmallCatamaran, SmallMultihull, DayBoat, Boat, object)) - - vereq(Pedalo.__mro__, - (Pedalo, PedalWheelBoat, EngineLess, SmallCatamaran, - SmallMultihull, DayBoat, WheelBoat, Boat, object)) - -# see "A Monotonic Superclass Linearization for Dylan", -# by Kim Barrett et al. (OOPSLA 1996) -def consistency_with_epg(): - if verbose: print("Testing consistentcy with EPG...") - class Pane(object): pass - class ScrollingMixin(object): pass - class EditingMixin(object): pass - class ScrollablePane(Pane,ScrollingMixin): pass - class EditablePane(Pane,EditingMixin): pass - class EditableScrollablePane(ScrollablePane,EditablePane): pass - - vereq(EditableScrollablePane.__mro__, - (EditableScrollablePane, ScrollablePane, EditablePane, - Pane, ScrollingMixin, EditingMixin, object)) - -mro_err_msg = """Cannot create a consistent method resolution + def test_mro_disagreement(self): + # Testing error messages for MRO disagreement... + mro_err_msg = """Cannot create a consistent method resolution order (MRO) for bases """ -def mro_disagreement(): - if verbose: print("Testing error messages for MRO disagreement...") - def raises(exc, expected, callable, *args): - try: - callable(*args) - except exc as msg: - if not str(msg).startswith(expected): - raise TestFailed("Message %r, expected %r" % (str(msg), - expected)) - else: - raise TestFailed("Expected %s" % exc) - class A(object): pass - class B(A): pass - class C(object): pass - # Test some very simple errors - raises(TypeError, "duplicate base class A", - type, "X", (A, A), {}) - raises(TypeError, mro_err_msg, - type, "X", (A, B), {}) - raises(TypeError, mro_err_msg, - type, "X", (A, C, B), {}) - # Test a slightly more complex error - class GridLayout(object): pass - class HorizontalGrid(GridLayout): pass - class VerticalGrid(GridLayout): pass - class HVGrid(HorizontalGrid, VerticalGrid): pass - class VHGrid(VerticalGrid, HorizontalGrid): pass - raises(TypeError, mro_err_msg, - type, "ConfusedGrid", (HVGrid, VHGrid), {}) - -def objects(): - if verbose: print("Testing object class...") - a = object() - vereq(a.__class__, object) - vereq(type(a), object) - b = object() - verify(a is not b) - verify(not hasattr(a, "foo")) - try: - a.foo = 12 - except (AttributeError, TypeError): - pass - else: - verify(0, "object() should not allow setting a foo attribute") - verify(not hasattr(object(), "__dict__")) - - class Cdict(object): - pass - x = Cdict() - vereq(x.__dict__, {}) - x.foo = 1 - vereq(x.foo, 1) - vereq(x.__dict__, {'foo': 1}) - -def slots(): - if verbose: print("Testing __slots__...") - class C0(object): - __slots__ = [] - x = C0() - verify(not hasattr(x, "__dict__")) - verify(not hasattr(x, "foo")) - - class C1(object): - __slots__ = ['a'] - x = C1() - verify(not hasattr(x, "__dict__")) - verify(not hasattr(x, "a")) - x.a = 1 - vereq(x.a, 1) - x.a = None - veris(x.a, None) - del x.a - verify(not hasattr(x, "a")) - - class C3(object): - __slots__ = ['a', 'b', 'c'] - x = C3() - verify(not hasattr(x, "__dict__")) - verify(not hasattr(x, 'a')) - verify(not hasattr(x, 'b')) - verify(not hasattr(x, 'c')) - x.a = 1 - x.b = 2 - x.c = 3 - vereq(x.a, 1) - vereq(x.b, 2) - vereq(x.c, 3) - - class C4(object): - """Validate name mangling""" - __slots__ = ['__a'] - def __init__(self, value): - self.__a = value - def get(self): - return self.__a - x = C4(5) - verify(not hasattr(x, '__dict__')) - verify(not hasattr(x, '__a')) - vereq(x.get(), 5) - try: - x.__a = 6 - except AttributeError: - pass - else: - raise TestFailed("Double underscored names not mangled") - - # Make sure slot names are proper identifiers - try: - class C(object): - __slots__ = [None] - except TypeError: - pass - else: - raise TestFailed("[None] slots not caught") - try: - class C(object): - __slots__ = ["foo bar"] - except TypeError: - pass - else: - raise TestFailed("['foo bar'] slots not caught") - try: - class C(object): - __slots__ = ["foo\0bar"] - except TypeError: - pass - else: - raise TestFailed("['foo\\0bar'] slots not caught") - try: - class C(object): - __slots__ = ["1"] - except TypeError: - pass - else: - raise TestFailed("['1'] slots not caught") - try: - class C(object): - __slots__ = [""] - except TypeError: - pass - else: - raise TestFailed("[''] slots not caught") - class C(object): - __slots__ = ["a", "a_b", "_a", "A0123456789Z"] - # XXX(nnorwitz): was there supposed to be something tested - # from the class above? - - # Test a single string is not expanded as a sequence. - class C(object): - __slots__ = "abc" - c = C() - c.abc = 5 - vereq(c.abc, 5) - - # Test unicode slot names - # Test a single unicode string is not expanded as a sequence. - class C(object): - __slots__ = "abc" - c = C() - c.abc = 5 - vereq(c.abc, 5) - - # _unicode_to_string used to modify slots in certain circumstances - slots = ("foo", "bar") - class C(object): - __slots__ = slots - x = C() - x.foo = 5 - vereq(x.foo, 5) - veris(type(slots[0]), str) - # this used to leak references - try: - class C(object): - __slots__ = [chr(128)] - except (TypeError, UnicodeEncodeError): - pass - else: - raise TestFailed("[unichr(128)] slots not caught") - - # Test leaks - class Counted(object): - counter = 0 # counts the number of instances alive - def __init__(self): - Counted.counter += 1 - def __del__(self): - Counted.counter -= 1 - class C(object): - __slots__ = ['a', 'b', 'c'] - x = C() - x.a = Counted() - x.b = Counted() - x.c = Counted() - vereq(Counted.counter, 3) - del x - vereq(Counted.counter, 0) - class D(C): - pass - x = D() - x.a = Counted() - x.z = Counted() - vereq(Counted.counter, 2) - del x - vereq(Counted.counter, 0) - class E(D): - __slots__ = ['e'] - x = E() - x.a = Counted() - x.z = Counted() - x.e = Counted() - vereq(Counted.counter, 3) - del x - vereq(Counted.counter, 0) - - # Test cyclical leaks [SF bug 519621] - class F(object): - __slots__ = ['a', 'b'] - log = [] - s = F() - s.a = [Counted(), s] - vereq(Counted.counter, 1) - s = None - import gc - gc.collect() - vereq(Counted.counter, 0) - - # Test lookup leaks [SF bug 572567] - import sys,gc - class G(object): - def __cmp__(self, other): - return 0 - g = G() - orig_objects = len(gc.get_objects()) - for i in range(10): - g==g - new_objects = len(gc.get_objects()) - vereq(orig_objects, new_objects) - class H(object): - __slots__ = ['a', 'b'] - def __init__(self): - self.a = 1 - self.b = 2 - def __del__(self): - assert self.a == 1 - assert self.b == 2 - - save_stderr = sys.stderr - sys.stderr = sys.stdout - h = H() - try: - del h - finally: - sys.stderr = save_stderr - -def slotspecials(): - if verbose: print("Testing __dict__ and __weakref__ in __slots__...") - - class D(object): - __slots__ = ["__dict__"] - a = D() - verify(hasattr(a, "__dict__")) - verify(not hasattr(a, "__weakref__")) - a.foo = 42 - vereq(a.__dict__, {"foo": 42}) - - class W(object): - __slots__ = ["__weakref__"] - a = W() - verify(hasattr(a, "__weakref__")) - verify(not hasattr(a, "__dict__")) - try: - a.foo = 42 - except AttributeError: - pass - else: - raise TestFailed("shouldn't be allowed to set a.foo") - - class C1(W, D): - __slots__ = [] - a = C1() - verify(hasattr(a, "__dict__")) - verify(hasattr(a, "__weakref__")) - a.foo = 42 - vereq(a.__dict__, {"foo": 42}) - - class C2(D, W): - __slots__ = [] - a = C2() - verify(hasattr(a, "__dict__")) - verify(hasattr(a, "__weakref__")) - a.foo = 42 - vereq(a.__dict__, {"foo": 42}) - -# MRO order disagreement -# -# class C3(C1, C2): -# __slots__ = [] -# -# class C4(C2, C1): -# __slots__ = [] - -def dynamics(): - if verbose: print("Testing class attribute propagation...") - class D(object): - pass - class E(D): - pass - class F(D): - pass - D.foo = 1 - vereq(D.foo, 1) - # Test that dynamic attributes are inherited - vereq(E.foo, 1) - vereq(F.foo, 1) - # Test dynamic instances - class C(object): - pass - a = C() - verify(not hasattr(a, "foobar")) - C.foobar = 2 - vereq(a.foobar, 2) - C.method = lambda self: 42 - vereq(a.method(), 42) - C.__repr__ = lambda self: "C()" - vereq(repr(a), "C()") - C.__int__ = lambda self: 100 - vereq(int(a), 100) - vereq(a.foobar, 2) - verify(not hasattr(a, "spam")) - def mygetattr(self, name): - if name == "spam": - return "spam" - raise AttributeError - C.__getattr__ = mygetattr - vereq(a.spam, "spam") - a.new = 12 - vereq(a.new, 12) - def mysetattr(self, name, value): - if name == "spam": - raise AttributeError - return object.__setattr__(self, name, value) - C.__setattr__ = mysetattr - try: - a.spam = "not spam" - except AttributeError: - pass - else: - verify(0, "expected AttributeError") - vereq(a.spam, "spam") - class D(C): - pass - d = D() - d.foo = 1 - vereq(d.foo, 1) - - # Test handling of int*seq and seq*int - class I(int): - pass - vereq("a"*I(2), "aa") - vereq(I(2)*"a", "aa") - vereq(2*I(3), 6) - vereq(I(3)*2, 6) - vereq(I(3)*I(2), 6) - - # Test handling of long*seq and seq*long - class L(int): - pass - vereq("a"*L(2), "aa") - vereq(L(2)*"a", "aa") - vereq(2*L(3), 6) - vereq(L(3)*2, 6) - vereq(L(3)*L(2), 6) - - # Test comparison of classes with dynamic metaclasses - class dynamicmetaclass(type): - pass - class someclass(metaclass=dynamicmetaclass): - pass - verify(someclass != object) - -def errors(): - if verbose: print("Testing errors...") - - try: - class C(list, dict): - pass - except TypeError: - pass - else: - verify(0, "inheritance from both list and dict should be illegal") - - try: - class C(object, None): - pass - except TypeError: - pass - else: - verify(0, "inheritance from non-type should be illegal") - class Classic: - pass - - try: - class C(type(len)): - pass - except TypeError: - pass - else: - verify(0, "inheritance from CFunction should be illegal") - - try: - class C(object): - __slots__ = 1 - except TypeError: - pass - else: - verify(0, "__slots__ = 1 should be illegal") - - try: - class C(object): - __slots__ = [1] - except TypeError: - pass - else: - verify(0, "__slots__ = [1] should be illegal") - - class M1(type): - pass - class M2(type): - pass - class A1(object, metaclass=M1): - pass - class A2(object, metaclass=M2): - pass - try: - class B(A1, A2): - pass - except TypeError: - pass - else: - verify(0, "finding the most derived metaclass should have failed") - -def classmethods(): - if verbose: print("Testing class methods...") - class C(object): - def foo(*a): return a - goo = classmethod(foo) - c = C() - vereq(C.goo(1), (C, 1)) - vereq(c.goo(1), (C, 1)) - vereq(c.foo(1), (c, 1)) - class D(C): - pass - d = D() - vereq(D.goo(1), (D, 1)) - vereq(d.goo(1), (D, 1)) - vereq(d.foo(1), (d, 1)) - vereq(D.foo(d, 1), (d, 1)) - # Test for a specific crash (SF bug 528132) - def f(cls, arg): return (cls, arg) - ff = classmethod(f) - vereq(ff.__get__(0, int)(42), (int, 42)) - vereq(ff.__get__(0)(42), (int, 42)) - - # Test super() with classmethods (SF bug 535444) - veris(C.goo.__self__, C) - veris(D.goo.__self__, D) - veris(super(D,D).goo.__self__, D) - veris(super(D,d).goo.__self__, D) - vereq(super(D,D).goo(), (D,)) - vereq(super(D,d).goo(), (D,)) - - # Verify that argument is checked for callability (SF bug 753451) - try: - classmethod(1).__get__(1) - except TypeError: - pass - else: - raise TestFailed("classmethod should check for callability") - - # Verify that classmethod() doesn't allow keyword args - try: - classmethod(f, kw=1) - except TypeError: - pass - else: - raise TestFailed("classmethod shouldn't accept keyword args") - -def classmethods_in_c(): - if verbose: print("Testing C-based class methods...") - import xxsubtype as spam - a = (1, 2, 3) - d = {'abc': 123} - x, a1, d1 = spam.spamlist.classmeth(*a, **d) - veris(x, spam.spamlist) - vereq(a, a1) - vereq(d, d1) - x, a1, d1 = spam.spamlist().classmeth(*a, **d) - veris(x, spam.spamlist) - vereq(a, a1) - vereq(d, d1) - -def staticmethods(): - if verbose: print("Testing static methods...") - class C(object): - def foo(*a): return a - goo = staticmethod(foo) - c = C() - vereq(C.goo(1), (1,)) - vereq(c.goo(1), (1,)) - vereq(c.foo(1), (c, 1,)) - class D(C): - pass - d = D() - vereq(D.goo(1), (1,)) - vereq(d.goo(1), (1,)) - vereq(d.foo(1), (d, 1)) - vereq(D.foo(d, 1), (d, 1)) - -def staticmethods_in_c(): - if verbose: print("Testing C-based static methods...") - import xxsubtype as spam - a = (1, 2, 3) - d = {"abc": 123} - x, a1, d1 = spam.spamlist.staticmeth(*a, **d) - veris(x, None) - vereq(a, a1) - vereq(d, d1) - x, a1, d2 = spam.spamlist().staticmeth(*a, **d) - veris(x, None) - vereq(a, a1) - vereq(d, d1) - -def classic(): - if verbose: print("Testing classic classes...") - class C: - def foo(*a): return a - goo = classmethod(foo) - c = C() - vereq(C.goo(1), (C, 1)) - vereq(c.goo(1), (C, 1)) - vereq(c.foo(1), (c, 1)) - class D(C): - pass - d = D() - vereq(D.goo(1), (D, 1)) - vereq(d.goo(1), (D, 1)) - vereq(d.foo(1), (d, 1)) - vereq(D.foo(d, 1), (d, 1)) - class E: # *not* subclassing from C - foo = C.foo - r = repr(E().foo) - verify(r.startswith("= 0) - vereq(str(c1), repr(c1)) - verify(-1 not in c1) - for i in range(10): - verify(i in c1) - verify(10 not in c1) - # Test the default behavior for dynamic classes - class D(object): - def __getitem__(self, i): - if 0 <= i < 10: return i - raise IndexError - d1 = D() - d2 = D() - verify(not not d1) - verify(id(d1) != id(d2)) - hash(d1) - hash(d2) - ##vereq(cmp(d1, d2), cmp(id(d1), id(d2))) - vereq(d1, d1) - verify(d1 != d2) - verify(not d1 != d1) - verify(not d1 == d2) - # Note that the module name appears in str/repr, and that varies - # depending on whether this test is run standalone or from a framework. - verify(str(d1).find('D object at ') >= 0) - vereq(str(d1), repr(d1)) - verify(-1 not in d1) - for i in range(10): - verify(i in d1) - verify(10 not in d1) - # Test overridden behavior for static classes - class Proxy(object): - def __init__(self, x): - self.x = x - def __bool__(self): - return not not self.x - def __hash__(self): - return hash(self.x) - def __eq__(self, other): - return self.x == other - def __ne__(self, other): - return self.x != other - def __cmp__(self, other): - return cmp(self.x, other.x) - def __str__(self): - return "Proxy:%s" % self.x - def __repr__(self): - return "Proxy(%r)" % self.x - def __contains__(self, value): - return value in self.x - p0 = Proxy(0) - p1 = Proxy(1) - p_1 = Proxy(-1) - verify(not p0) - verify(not not p1) - vereq(hash(p0), hash(0)) - vereq(p0, p0) - verify(p0 != p1) - verify(not p0 != p0) - vereq(not p0, p1) - vereq(cmp(p0, p1), -1) - vereq(cmp(p0, p0), 0) - vereq(cmp(p0, p_1), 1) - vereq(str(p0), "Proxy:0") - vereq(repr(p0), "Proxy(0)") - p10 = Proxy(range(10)) - verify(-1 not in p10) - for i in range(10): - verify(i in p10) - verify(10 not in p10) - # Test overridden behavior for dynamic classes - class DProxy(object): - def __init__(self, x): - self.x = x - def __bool__(self): - return not not self.x - def __hash__(self): - return hash(self.x) - def __eq__(self, other): - return self.x == other - def __ne__(self, other): - return self.x != other - def __cmp__(self, other): - return cmp(self.x, other.x) - def __str__(self): - return "DProxy:%s" % self.x - def __repr__(self): - return "DProxy(%r)" % self.x - def __contains__(self, value): - return value in self.x - p0 = DProxy(0) - p1 = DProxy(1) - p_1 = DProxy(-1) - verify(not p0) - verify(not not p1) - vereq(hash(p0), hash(0)) - vereq(p0, p0) - verify(p0 != p1) - verify(not p0 != p0) - vereq(not p0, p1) - vereq(cmp(p0, p1), -1) - vereq(cmp(p0, p0), 0) - vereq(cmp(p0, p_1), 1) - vereq(str(p0), "DProxy:0") - vereq(repr(p0), "DProxy(0)") - p10 = DProxy(range(10)) - verify(-1 not in p10) - for i in range(10): - verify(i in p10) - verify(10 not in p10) -## # Safety test for __cmp__ -## def unsafecmp(a, b): -## try: -## a.__class__.__cmp__(a, b) -## except TypeError: -## pass -## else: -## raise TestFailed, "shouldn't allow %s.__cmp__(%r, %r)" % ( -## a.__class__, a, b) -## unsafecmp(u"123", "123") -## unsafecmp("123", u"123") -## unsafecmp(1, 1.0) -## unsafecmp(1.0, 1) -## unsafecmp(1, 1L) -## unsafecmp(1L, 1) - -def recursions(): - if verbose: - print("Testing recursion checks ...") - -## class Letter(str): -## def __new__(cls, letter): -## if letter == 'EPS': -## return str.__new__(cls) -## return str.__new__(cls, letter) -## def __str__(self): -## if not self: -## return 'EPS' -## return self -## # sys.stdout needs to be the original to trigger the recursion bug -## import sys -## test_stdout = sys.stdout -## sys.stdout = get_original_stdout() -## try: -## # nothing should actually be printed, this should raise an exception -## print(Letter('w')) -## except RuntimeError: -## pass -## else: -## raise TestFailed, "expected a RuntimeError for print recursion" -## sys.stdout = test_stdout - -def weakrefs(): - if verbose: print("Testing weak references...") - import weakref - class C(object): - pass - c = C() - r = weakref.ref(c) - verify(r() is c) - del c - verify(r() is None) - del r - class NoWeak(object): - __slots__ = ['foo'] - no = NoWeak() - try: - weakref.ref(no) - except TypeError as msg: - verify(str(msg).find("weak reference") >= 0) - else: - verify(0, "weakref.ref(no) should be illegal") - class Weak(object): - __slots__ = ['foo', '__weakref__'] - yes = Weak() - r = weakref.ref(yes) - verify(r() is yes) - del yes - verify(r() is None) - del r - -def properties(): - if verbose: print("Testing property...") - class C(object): - def getx(self): - return self.__x - def setx(self, value): - self.__x = value - def delx(self): - del self.__x - x = property(getx, setx, delx, doc="I'm the x property.") - a = C() - verify(not hasattr(a, "x")) - a.x = 42 - vereq(a._C__x, 42) - vereq(a.x, 42) - del a.x - verify(not hasattr(a, "x")) - verify(not hasattr(a, "_C__x")) - C.x.__set__(a, 100) - vereq(C.x.__get__(a), 100) - C.x.__delete__(a) - verify(not hasattr(a, "x")) - - raw = C.__dict__['x'] - verify(isinstance(raw, property)) - - attrs = dir(raw) - verify("__doc__" in attrs) - verify("fget" in attrs) - verify("fset" in attrs) - verify("fdel" in attrs) - - vereq(raw.__doc__, "I'm the x property.") - verify(raw.fget is C.__dict__['getx']) - verify(raw.fset is C.__dict__['setx']) - verify(raw.fdel is C.__dict__['delx']) - - for attr in "__doc__", "fget", "fset", "fdel": - try: - setattr(raw, attr, 42) - except AttributeError as msg: - if str(msg).find('readonly') < 0: - raise TestFailed("when setting readonly attr %r on a " - "property, got unexpected AttributeError " - "msg %r" % (attr, str(msg))) - else: - raise TestFailed("expected AttributeError from trying to set " - "readonly %r attr on a property" % attr) - - class D(object): - __getitem__ = property(lambda s: 1/0) - - d = D() - try: - for i in d: - str(i) - except ZeroDivisionError: - pass - else: - raise TestFailed("expected ZeroDivisionError from bad property") - - class E(object): - def getter(self): - "getter method" - return 0 - def setter(self, value): - "setter method" - pass - prop = property(getter) - vereq(prop.__doc__, "getter method") - prop2 = property(fset=setter) - vereq(prop2.__doc__, None) - - # this segfaulted in 2.5b2 - try: - import _testcapi - except ImportError: - pass - else: - class X(object): - p = property(_testcapi.test_with_docstring) - - -def properties_plus(): - class C(object): - foo = property(doc="hello") - @foo.getter - def foo(self): - return self._foo - @foo.setter - def foo(self, value): - self._foo = abs(value) - @foo.deleter - def foo(self): - del self._foo - c = C() - assert C.foo.__doc__ == "hello" - assert not hasattr(c, "foo") - c.foo = -42 - assert hasattr(c, '_foo') - assert c._foo == 42 - assert c.foo == 42 - del c.foo - assert not hasattr(c, '_foo') - assert not hasattr(c, "foo") - - class D(C): - @C.foo.deleter - def foo(self): + def raises(exc, expected, callable, *args): try: - del self._foo - except AttributeError: - pass - d = D() - d.foo = 24 - assert d.foo == 24 - del d.foo - del d.foo + callable(*args) + except exc as msg: + if not str(msg).startswith(expected): + self.fail("Message %r, expected %r" % (str(msg), expected)) + else: + self.fail("Expected %s" % exc) - class E(object): - @property - def foo(self): - return self._foo - @foo.setter - def foo(self, value): - raise RuntimeError - @foo.setter - def foo(self, value): - self._foo = abs(value) - @foo.deleter - def foo(self, value=None): - del self._foo + class A(object): pass + class B(A): pass + class C(object): pass - e = E() - e.foo = -42 - assert e.foo == 42 - del e.foo + # Test some very simple errors + raises(TypeError, "duplicate base class A", + type, "X", (A, A), {}) + raises(TypeError, mro_err_msg, + type, "X", (A, B), {}) + raises(TypeError, mro_err_msg, + type, "X", (A, C, B), {}) + # Test a slightly more complex error + class GridLayout(object): pass + class HorizontalGrid(GridLayout): pass + class VerticalGrid(GridLayout): pass + class HVGrid(HorizontalGrid, VerticalGrid): pass + class VHGrid(VerticalGrid, HorizontalGrid): pass + raises(TypeError, mro_err_msg, + type, "ConfusedGrid", (HVGrid, VHGrid), {}) - class F(E): - @E.foo.deleter - def foo(self): - del self._foo - @foo.setter - def foo(self, value): - self._foo = max(0, value) - f = F() - f.foo = -10 - assert f.foo == 0 - del f.foo - - -def supers(): - if verbose: print("Testing super...") - - class A(object): - def meth(self, a): - return "A(%r)" % a - - vereq(A().meth(1), "A(1)") - - class B(A): - def __init__(self): - self.__super = super(B, self) - def meth(self, a): - return "B(%r)" % a + self.__super.meth(a) - - vereq(B().meth(2), "B(2)A(2)") - - class C(A): - def meth(self, a): - return "C(%r)" % a + self.__super.meth(a) - C._C__super = super(C) - - vereq(C().meth(3), "C(3)A(3)") - - class D(C, B): - def meth(self, a): - return "D(%r)" % a + super(D, self).meth(a) - - vereq(D().meth(4), "D(4)C(4)B(4)A(4)") - - # Test for subclassing super - - class mysuper(super): - def __init__(self, *args): - return super(mysuper, self).__init__(*args) - - class E(D): - def meth(self, a): - return "E(%r)" % a + mysuper(E, self).meth(a) - - vereq(E().meth(5), "E(5)D(5)C(5)B(5)A(5)") - - class F(E): - def meth(self, a): - s = self.__super # == mysuper(F, self) - return "F(%r)[%s]" % (a, s.__class__.__name__) + s.meth(a) - F._F__super = mysuper(F) - - vereq(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)") - - # Make sure certain errors are raised - - try: - super(D, 42) - except TypeError: - pass - else: - raise TestFailed("shouldn't allow super(D, 42)") - - try: - super(D, C()) - except TypeError: - pass - else: - raise TestFailed("shouldn't allow super(D, C())") - - try: - super(D).__get__(12) - except TypeError: - pass - else: - raise TestFailed("shouldn't allow super(D).__get__(12)") - - try: - super(D).__get__(C()) - except TypeError: - pass - else: - raise TestFailed("shouldn't allow super(D).__get__(C())") - - # Make sure data descriptors can be overridden and accessed via super - # (new feature in Python 2.3) - - class DDbase(object): - def getx(self): return 42 - x = property(getx) - - class DDsub(DDbase): - def getx(self): return "hello" - x = property(getx) - - dd = DDsub() - vereq(dd.x, "hello") - vereq(super(DDsub, dd).x, 42) - - # Ensure that super() lookup of descriptor from classmethod - # works (SF ID# 743627) - - class Base(object): - aProp = property(lambda self: "foo") - - class Sub(Base): - @classmethod - def test(klass): - return super(Sub,klass).aProp - - veris(Sub.test(), Base.aProp) - - # Verify that super() doesn't allow keyword args - try: - super(Base, kw=1) - except TypeError: - pass - else: - raise TestFailed("super shouldn't accept keyword args") - -def inherits(): - if verbose: print("Testing inheritance from basic types...") - - class hexint(int): - def __repr__(self): - return hex(self) - def __add__(self, other): - return hexint(int.__add__(self, other)) - # (Note that overriding __radd__ doesn't work, - # because the int type gets first dibs.) - vereq(repr(hexint(7) + 9), "0x10") - vereq(repr(hexint(1000) + 7), "0x3ef") - a = hexint(12345) - vereq(a, 12345) - vereq(int(a), 12345) - verify(int(a).__class__ is int) - vereq(hash(a), hash(12345)) - verify((+a).__class__ is int) - verify((a >> 0).__class__ is int) - verify((a << 0).__class__ is int) - verify((hexint(0) << 12).__class__ is int) - verify((hexint(0) >> 12).__class__ is int) - - class octlong(int): - __slots__ = [] - def __str__(self): - return oct(self) - def __add__(self, other): - return self.__class__(super(octlong, self).__add__(other)) - __radd__ = __add__ - vereq(str(octlong(3) + 5), "0o10") - # (Note that overriding __radd__ here only seems to work - # because the example uses a short int left argument.) - vereq(str(5 + octlong(3000)), "0o5675") - a = octlong(12345) - vereq(a, 12345) - vereq(int(a), 12345) - vereq(hash(a), hash(12345)) - verify(int(a).__class__ is int) - verify((+a).__class__ is int) - verify((-a).__class__ is int) - verify((-octlong(0)).__class__ is int) - verify((a >> 0).__class__ is int) - verify((a << 0).__class__ is int) - verify((a - 0).__class__ is int) - verify((a * 1).__class__ is int) - verify((a ** 1).__class__ is int) - verify((a // 1).__class__ is int) - verify((1 * a).__class__ is int) - verify((a | 0).__class__ is int) - verify((a ^ 0).__class__ is int) - verify((a & -1).__class__ is int) - verify((octlong(0) << 12).__class__ is int) - verify((octlong(0) >> 12).__class__ is int) - verify(abs(octlong(0)).__class__ is int) - - # Because octlong overrides __add__, we can't check the absence of +0 - # optimizations using octlong. - class longclone(int): - pass - a = longclone(1) - verify((a + 0).__class__ is int) - verify((0 + a).__class__ is int) - - # Check that negative clones don't segfault - a = longclone(-1) - vereq(a.__dict__, {}) - vereq(int(a), -1) # verify PyNumber_Long() copies the sign bit - - class precfloat(float): - __slots__ = ['prec'] - def __init__(self, value=0.0, prec=12): - self.prec = int(prec) - def __repr__(self): - return "%.*g" % (self.prec, self) - vereq(repr(precfloat(1.1)), "1.1") - a = precfloat(12345) - vereq(a, 12345.0) - vereq(float(a), 12345.0) - verify(float(a).__class__ is float) - vereq(hash(a), hash(12345.0)) - verify((+a).__class__ is float) - - class madcomplex(complex): - def __repr__(self): - return "%.17gj%+.17g" % (self.imag, self.real) - a = madcomplex(-3, 4) - vereq(repr(a), "4j-3") - base = complex(-3, 4) - veris(base.__class__, complex) - vereq(a, base) - vereq(complex(a), base) - veris(complex(a).__class__, complex) - a = madcomplex(a) # just trying another form of the constructor - vereq(repr(a), "4j-3") - vereq(a, base) - vereq(complex(a), base) - veris(complex(a).__class__, complex) - vereq(hash(a), hash(base)) - veris((+a).__class__, complex) - veris((a + 0).__class__, complex) - vereq(a + 0, base) - veris((a - 0).__class__, complex) - vereq(a - 0, base) - veris((a * 1).__class__, complex) - vereq(a * 1, base) - veris((a / 1).__class__, complex) - vereq(a / 1, base) - - class madtuple(tuple): - _rev = None - def rev(self): - if self._rev is not None: - return self._rev - L = list(self) - L.reverse() - self._rev = self.__class__(L) - return self._rev - a = madtuple((1,2,3,4,5,6,7,8,9,0)) - vereq(a, (1,2,3,4,5,6,7,8,9,0)) - vereq(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1))) - vereq(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0))) - for i in range(512): - t = madtuple(range(i)) - u = t.rev() - v = u.rev() - vereq(v, t) - a = madtuple((1,2,3,4,5)) - vereq(tuple(a), (1,2,3,4,5)) - verify(tuple(a).__class__ is tuple) - vereq(hash(a), hash((1,2,3,4,5))) - verify(a[:].__class__ is tuple) - verify((a * 1).__class__ is tuple) - verify((a * 0).__class__ is tuple) - verify((a + ()).__class__ is tuple) - a = madtuple(()) - vereq(tuple(a), ()) - verify(tuple(a).__class__ is tuple) - verify((a + a).__class__ is tuple) - verify((a * 0).__class__ is tuple) - verify((a * 1).__class__ is tuple) - verify((a * 2).__class__ is tuple) - verify(a[:].__class__ is tuple) - - class madstring(str): - _rev = None - def rev(self): - if self._rev is not None: - return self._rev - L = list(self) - L.reverse() - self._rev = self.__class__("".join(L)) - return self._rev - s = madstring("abcdefghijklmnopqrstuvwxyz") - vereq(s, "abcdefghijklmnopqrstuvwxyz") - vereq(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba")) - vereq(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz")) - for i in range(256): - s = madstring("".join(map(chr, range(i)))) - t = s.rev() - u = t.rev() - vereq(u, s) - s = madstring("12345") - vereq(str(s), "12345") - verify(str(s).__class__ is str) - - base = "\x00" * 5 - s = madstring(base) - vereq(s, base) - vereq(str(s), base) - verify(str(s).__class__ is str) - vereq(hash(s), hash(base)) - vereq({s: 1}[base], 1) - vereq({base: 1}[s], 1) - verify((s + "").__class__ is str) - vereq(s + "", base) - verify(("" + s).__class__ is str) - vereq("" + s, base) - verify((s * 0).__class__ is str) - vereq(s * 0, "") - verify((s * 1).__class__ is str) - vereq(s * 1, base) - verify((s * 2).__class__ is str) - vereq(s * 2, base + base) - verify(s[:].__class__ is str) - vereq(s[:], base) - verify(s[0:0].__class__ is str) - vereq(s[0:0], "") - verify(s.strip().__class__ is str) - vereq(s.strip(), base) - verify(s.lstrip().__class__ is str) - vereq(s.lstrip(), base) - verify(s.rstrip().__class__ is str) - vereq(s.rstrip(), base) - identitytab = {} - verify(s.translate(identitytab).__class__ is str) - vereq(s.translate(identitytab), base) - verify(s.replace("x", "x").__class__ is str) - vereq(s.replace("x", "x"), base) - verify(s.ljust(len(s)).__class__ is str) - vereq(s.ljust(len(s)), base) - verify(s.rjust(len(s)).__class__ is str) - vereq(s.rjust(len(s)), base) - verify(s.center(len(s)).__class__ is str) - vereq(s.center(len(s)), base) - verify(s.lower().__class__ is str) - vereq(s.lower(), base) - - class madunicode(str): - _rev = None - def rev(self): - if self._rev is not None: - return self._rev - L = list(self) - L.reverse() - self._rev = self.__class__("".join(L)) - return self._rev - u = madunicode("ABCDEF") - vereq(u, "ABCDEF") - vereq(u.rev(), madunicode("FEDCBA")) - vereq(u.rev().rev(), madunicode("ABCDEF")) - base = "12345" - u = madunicode(base) - vereq(str(u), base) - verify(str(u).__class__ is str) - vereq(hash(u), hash(base)) - vereq({u: 1}[base], 1) - vereq({base: 1}[u], 1) - verify(u.strip().__class__ is str) - vereq(u.strip(), base) - verify(u.lstrip().__class__ is str) - vereq(u.lstrip(), base) - verify(u.rstrip().__class__ is str) - vereq(u.rstrip(), base) - verify(u.replace("x", "x").__class__ is str) - vereq(u.replace("x", "x"), base) - verify(u.replace("xy", "xy").__class__ is str) - vereq(u.replace("xy", "xy"), base) - verify(u.center(len(u)).__class__ is str) - vereq(u.center(len(u)), base) - verify(u.ljust(len(u)).__class__ is str) - vereq(u.ljust(len(u)), base) - verify(u.rjust(len(u)).__class__ is str) - vereq(u.rjust(len(u)), base) - verify(u.lower().__class__ is str) - vereq(u.lower(), base) - verify(u.upper().__class__ is str) - vereq(u.upper(), base) - verify(u.capitalize().__class__ is str) - vereq(u.capitalize(), base) - verify(u.title().__class__ is str) - vereq(u.title(), base) - verify((u + "").__class__ is str) - vereq(u + "", base) - verify(("" + u).__class__ is str) - vereq("" + u, base) - verify((u * 0).__class__ is str) - vereq(u * 0, "") - verify((u * 1).__class__ is str) - vereq(u * 1, base) - verify((u * 2).__class__ is str) - vereq(u * 2, base + base) - verify(u[:].__class__ is str) - vereq(u[:], base) - verify(u[0:0].__class__ is str) - vereq(u[0:0], "") - - class sublist(list): - pass - a = sublist(range(5)) - vereq(a, list(range(5))) - a.append("hello") - vereq(a, list(range(5)) + ["hello"]) - a[5] = 5 - vereq(a, list(range(6))) - a.extend(range(6, 20)) - vereq(a, list(range(20))) - a[-5:] = [] - vereq(a, list(range(15))) - del a[10:15] - vereq(len(a), 10) - vereq(a, list(range(10))) - vereq(list(a), list(range(10))) - vereq(a[0], 0) - vereq(a[9], 9) - vereq(a[-10], 0) - vereq(a[-1], 9) - vereq(a[:5], list(range(5))) - -## class CountedInput(file): -## """Counts lines read by self.readline(). - -## self.lineno is the 0-based ordinal of the last line read, up to -## a maximum of one greater than the number of lines in the file. - -## self.ateof is true if and only if the final "" line has been read, -## at which point self.lineno stops incrementing, and further calls -## to readline() continue to return "". -## """ - -## lineno = 0 -## ateof = 0 -## def readline(self): -## if self.ateof: -## return "" -## s = file.readline(self) -## # Next line works too. -## # s = super(CountedInput, self).readline() -## self.lineno += 1 -## if s == "": -## self.ateof = 1 -## return s - -## f = open(name=TESTFN, mode='w') -## lines = ['a\n', 'b\n', 'c\n'] -## try: -## f.writelines(lines) -## f.close() -## f = CountedInput(TESTFN) -## for (i, expected) in zip(list(range(1, 5)) + [4], lines + 2 * [""]): -## got = f.readline() -## vereq(expected, got) -## vereq(f.lineno, i) -## vereq(f.ateof, (i > len(lines))) -## f.close() -## finally: -## try: -## f.close() -## except: -## pass -## try: -## import os -## os.unlink(TESTFN) -## except: -## pass - -def keywords(): - if verbose: - print("Testing keyword args to basic type constructors ...") - vereq(int(x=1), 1) - vereq(float(x=2), 2.0) - vereq(int(x=3), 3) - vereq(complex(imag=42, real=666), complex(666, 42)) - vereq(str(object=500), '500') - vereq(str(object=b'abc', errors='strict'), 'abc') - vereq(tuple(sequence=range(3)), (0, 1, 2)) - vereq(list(sequence=(0, 1, 2)), list(range(3))) - # note: as of Python 2.3, dict() no longer has an "items" keyword arg - - for constructor in (int, float, int, complex, str, str, tuple, list): + def test_object_class(self): + # Testing object class... + a = object() + self.assertEqual(a.__class__, object) + self.assertEqual(type(a), object) + b = object() + self.assertNotEqual(a, b) + self.assertFalse(hasattr(a, "foo")) try: - constructor(bogus_keyword_arg=1) - except TypeError: + a.foo = 12 + except (AttributeError, TypeError): pass else: - raise TestFailed("expected TypeError from bogus keyword " - "argument to %r" % constructor) + self.fail("object() should not allow setting a foo attribute") + self.assertFalse(hasattr(object(), "__dict__")) -def str_subclass_as_dict_key(): - if verbose: - print("Testing a str subclass used as dict key ..") - - class cistr(str): - """Sublcass of str that computes __eq__ case-insensitively. - - Also computes a hash code of the string in canonical form. - """ - - def __init__(self, value): - self.canonical = value.lower() - self.hashcode = hash(self.canonical) - - def __eq__(self, other): - if not isinstance(other, cistr): - other = cistr(other) - return self.canonical == other.canonical - - def __hash__(self): - return self.hashcode - - vereq(cistr('ABC'), 'abc') - vereq('aBc', cistr('ABC')) - vereq(str(cistr('ABC')), 'ABC') - - d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3} - vereq(d[cistr('one')], 1) - vereq(d[cistr('tWo')], 2) - vereq(d[cistr('THrEE')], 3) - verify(cistr('ONe') in d) - vereq(d.get(cistr('thrEE')), 3) - -def classic_comparisons(): - if verbose: print("Testing classic comparisons...") - class classic: - pass - for base in (classic, int, object): - if verbose: print(" (base = %s)" % base) - class C(base): - def __init__(self, value): - self.value = int(value) - def __eq__(self, other): - if isinstance(other, C): - return self.value == other.value - if isinstance(other, int) or isinstance(other, int): - return self.value == other - return NotImplemented - def __ne__(self, other): - if isinstance(other, C): - return self.value != other.value - if isinstance(other, int) or isinstance(other, int): - return self.value != other - return NotImplemented - def __lt__(self, other): - if isinstance(other, C): - return self.value < other.value - if isinstance(other, int) or isinstance(other, int): - return self.value < other - return NotImplemented - def __le__(self, other): - if isinstance(other, C): - return self.value <= other.value - if isinstance(other, int) or isinstance(other, int): - return self.value <= other - return NotImplemented - def __gt__(self, other): - if isinstance(other, C): - return self.value > other.value - if isinstance(other, int) or isinstance(other, int): - return self.value > other - return NotImplemented - def __ge__(self, other): - if isinstance(other, C): - return self.value >= other.value - if isinstance(other, int) or isinstance(other, int): - return self.value >= other - return NotImplemented - - c1 = C(1) - c2 = C(2) - c3 = C(3) - vereq(c1, 1) - c = {1: c1, 2: c2, 3: c3} - for x in 1, 2, 3: - for y in 1, 2, 3: - ##verify(cmp(c[x], c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y)) - for op in "<", "<=", "==", "!=", ">", ">=": - verify(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), - "x=%d, y=%d" % (x, y)) - ##verify(cmp(c[x], y) == cmp(x, y), "x=%d, y=%d" % (x, y)) - ##verify(cmp(x, c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y)) - -def rich_comparisons(): - if verbose: - print("Testing rich comparisons...") - class Z(complex): - pass - z = Z(1) - vereq(z, 1+0j) - vereq(1+0j, z) - class ZZ(complex): - def __eq__(self, other): - try: - return abs(self - other) <= 1e-6 - except: - return NotImplemented - zz = ZZ(1.0000003) - vereq(zz, 1+0j) - vereq(1+0j, zz) - - class classic: - pass - for base in (classic, int, object, list): - if verbose: print(" (base = %s)" % base) - class C(base): - def __init__(self, value): - self.value = int(value) - def __cmp__(self, other): - raise TestFailed("shouldn't call __cmp__") - def __eq__(self, other): - if isinstance(other, C): - return self.value == other.value - if isinstance(other, int) or isinstance(other, int): - return self.value == other - return NotImplemented - def __ne__(self, other): - if isinstance(other, C): - return self.value != other.value - if isinstance(other, int) or isinstance(other, int): - return self.value != other - return NotImplemented - def __lt__(self, other): - if isinstance(other, C): - return self.value < other.value - if isinstance(other, int) or isinstance(other, int): - return self.value < other - return NotImplemented - def __le__(self, other): - if isinstance(other, C): - return self.value <= other.value - if isinstance(other, int) or isinstance(other, int): - return self.value <= other - return NotImplemented - def __gt__(self, other): - if isinstance(other, C): - return self.value > other.value - if isinstance(other, int) or isinstance(other, int): - return self.value > other - return NotImplemented - def __ge__(self, other): - if isinstance(other, C): - return self.value >= other.value - if isinstance(other, int) or isinstance(other, int): - return self.value >= other - return NotImplemented - c1 = C(1) - c2 = C(2) - c3 = C(3) - vereq(c1, 1) - c = {1: c1, 2: c2, 3: c3} - for x in 1, 2, 3: - for y in 1, 2, 3: - for op in "<", "<=", "==", "!=", ">", ">=": - verify(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), - "x=%d, y=%d" % (x, y)) - verify(eval("c[x] %s y" % op) == eval("x %s y" % op), - "x=%d, y=%d" % (x, y)) - verify(eval("x %s c[y]" % op) == eval("x %s y" % op), - "x=%d, y=%d" % (x, y)) - -def descrdoc(): - if verbose: print("Testing descriptor doc strings...") - from _fileio import _FileIO - def check(descr, what): - vereq(descr.__doc__, what) - check(_FileIO.closed, "True if the file is closed") # getset descriptor - check(complex.real, "the real part of a complex number") # member descriptor - -def setclass(): - if verbose: print("Testing __class__ assignment...") - class C(object): pass - class D(object): pass - class E(object): pass - class F(D, E): pass - for cls in C, D, E, F: - for cls2 in C, D, E, F: - x = cls() - x.__class__ = cls2 - verify(x.__class__ is cls2) - x.__class__ = cls - verify(x.__class__ is cls) - def cant(x, C): - try: - x.__class__ = C - except TypeError: + class Cdict(object): pass - else: - raise TestFailed("shouldn't allow %r.__class__ = %r" % (x, C)) - try: - delattr(x, "__class__") - except TypeError: - pass - else: - raise TestFailed("shouldn't allow del %r.__class__" % x) - cant(C(), list) - cant(list(), C) - cant(C(), 1) - cant(C(), object) - cant(object(), list) - cant(list(), object) - class Int(int): __slots__ = [] - cant(2, Int) - cant(Int(), int) - cant(True, int) - cant(2, bool) - o = object() - cant(o, type(1)) - cant(o, type(None)) - del o - class G(object): - __slots__ = ["a", "b"] - class H(object): - __slots__ = ["b", "a"] - class I(object): - __slots__ = ["a", "b"] - class J(object): - __slots__ = ["c", "b"] - class K(object): - __slots__ = ["a", "b", "d"] - class L(H): - __slots__ = ["e"] - class M(I): - __slots__ = ["e"] - class N(J): - __slots__ = ["__weakref__"] - class P(J): - __slots__ = ["__dict__"] - class Q(J): - pass - class R(J): - __slots__ = ["__dict__", "__weakref__"] + x = Cdict() + self.assertEqual(x.__dict__, {}) + x.foo = 1 + self.assertEqual(x.foo, 1) + self.assertEqual(x.__dict__, {'foo': 1}) - for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)): - x = cls() + def test_slots(self): + # Testing __slots__... + class C0(object): + __slots__ = [] + x = C0() + self.assertFalse(hasattr(x, "__dict__")) + self.assertFalse(hasattr(x, "foo")) + + class C1(object): + __slots__ = ['a'] + x = C1() + self.assertFalse(hasattr(x, "__dict__")) + self.assertFalse(hasattr(x, "a")) x.a = 1 - x.__class__ = cls2 - verify(x.__class__ is cls2, - "assigning %r as __class__ for %r silently failed" % (cls2, x)) - vereq(x.a, 1) - x.__class__ = cls - verify(x.__class__ is cls, - "assigning %r as __class__ for %r silently failed" % (cls, x)) - vereq(x.a, 1) - for cls in G, J, K, L, M, N, P, R, list, Int: - for cls2 in G, J, K, L, M, N, P, R, list, Int: - if cls is cls2: - continue - cant(cls(), cls2) + self.assertEqual(x.a, 1) + x.a = None + self.assertEqual(x.a, None) + del x.a + self.assertFalse(hasattr(x, "a")) -def setdict(): - if verbose: print("Testing __dict__ assignment...") - class C(object): pass - a = C() - a.__dict__ = {'b': 1} - vereq(a.b, 1) - def cant(x, dict): + class C3(object): + __slots__ = ['a', 'b', 'c'] + x = C3() + self.assertFalse(hasattr(x, "__dict__")) + self.assertFalse(hasattr(x, 'a')) + self.assertFalse(hasattr(x, 'b')) + self.assertFalse(hasattr(x, 'c')) + x.a = 1 + x.b = 2 + x.c = 3 + self.assertEqual(x.a, 1) + self.assertEqual(x.b, 2) + self.assertEqual(x.c, 3) + + class C4(object): + """Validate name mangling""" + __slots__ = ['__a'] + def __init__(self, value): + self.__a = value + def get(self): + return self.__a + x = C4(5) + self.assertFalse(hasattr(x, '__dict__')) + self.assertFalse(hasattr(x, '__a')) + self.assertEqual(x.get(), 5) try: - x.__dict__ = dict - except (AttributeError, TypeError): + x.__a = 6 + except AttributeError: pass else: - raise TestFailed("shouldn't allow %r.__dict__ = %r" % (x, dict)) - cant(a, None) - cant(a, []) - cant(a, 1) - del a.__dict__ # Deleting __dict__ is allowed + self.fail("Double underscored names not mangled") - class Base(object): - pass - def verify_dict_readonly(x): - """ - x has to be an instance of a class inheriting from Base. - """ - cant(x, {}) + # Make sure slot names are proper identifiers try: - del x.__dict__ - except (AttributeError, TypeError): - pass - else: - raise TestFailed("shouldn't allow del %r.__dict__" % x) - dict_descr = Base.__dict__["__dict__"] - try: - dict_descr.__set__(x, {}) - except (AttributeError, TypeError): - pass - else: - raise TestFailed("dict_descr allowed access to %r's dict" % x) - - # Classes don't allow __dict__ assignment and have readonly dicts - class Meta1(type, Base): - pass - class Meta2(Base, type): - pass - class D(object): - __metaclass__ = Meta1 - class E(object): - __metaclass__ = Meta2 - for cls in C, D, E: - verify_dict_readonly(cls) - class_dict = cls.__dict__ - try: - class_dict["spam"] = "eggs" + class C(object): + __slots__ = [None] except TypeError: pass else: - raise TestFailed("%r's __dict__ can be modified" % cls) - - # Modules also disallow __dict__ assignment - class Module1(types.ModuleType, Base): - pass - class Module2(Base, types.ModuleType): - pass - for ModuleType in Module1, Module2: - mod = ModuleType("spam") - verify_dict_readonly(mod) - mod.__dict__["spam"] = "eggs" - - # Exception's __dict__ can be replaced, but not deleted - class Exception1(Exception, Base): - pass - class Exception2(Base, Exception): - pass - for ExceptionType in Exception, Exception1, Exception2: - e = ExceptionType() - e.__dict__ = {"a": 1} - vereq(e.a, 1) + self.fail("[None] slots not caught") try: - del e.__dict__ - except (TypeError, AttributeError): + class C(object): + __slots__ = ["foo bar"] + except TypeError: pass else: - raise TestFaied("%r's __dict__ can be deleted" % e) + self.fail("['foo bar'] slots not caught") + try: + class C(object): + __slots__ = ["foo\0bar"] + except TypeError: + pass + else: + self.fail("['foo\\0bar'] slots not caught") + try: + class C(object): + __slots__ = ["1"] + except TypeError: + pass + else: + self.fail("['1'] slots not caught") + try: + class C(object): + __slots__ = [""] + except TypeError: + pass + else: + self.fail("[''] slots not caught") + class C(object): + __slots__ = ["a", "a_b", "_a", "A0123456789Z"] + # XXX(nnorwitz): was there supposed to be something tested + # from the class above? + # Test a single string is not expanded as a sequence. + class C(object): + __slots__ = "abc" + c = C() + c.abc = 5 + self.assertEqual(c.abc, 5) -def pickles(): - if verbose: - print("Testing pickling and copying new-style classes and objects...") - import pickle + # Test unicode slot names + # Test a single unicode string is not expanded as a sequence. + class C(object): + __slots__ = "abc" + c = C() + c.abc = 5 + self.assertEqual(c.abc, 5) - def sorteditems(d): - return sorted(d.items()) + # _unicode_to_string used to modify slots in certain circumstances + slots = ("foo", "bar") + class C(object): + __slots__ = slots + x = C() + x.foo = 5 + self.assertEqual(x.foo, 5) + self.assert_(type(slots[0]) is str) + # this used to leak references + try: + class C(object): + __slots__ = [chr(128)] + except (TypeError, UnicodeEncodeError): + pass + else: + raise TestFailed("[chr(128)] slots not caught") - global C - class C(object): - def __init__(self, a, b): - super(C, self).__init__() - self.a = a - self.b = b - def __repr__(self): - return "C(%r, %r)" % (self.a, self.b) + # Test leaks + class Counted(object): + counter = 0 # counts the number of instances alive + def __init__(self): + Counted.counter += 1 + def __del__(self): + Counted.counter -= 1 + class C(object): + __slots__ = ['a', 'b', 'c'] + x = C() + x.a = Counted() + x.b = Counted() + x.c = Counted() + self.assertEqual(Counted.counter, 3) + del x + self.assertEqual(Counted.counter, 0) + class D(C): + pass + x = D() + x.a = Counted() + x.z = Counted() + self.assertEqual(Counted.counter, 2) + del x + self.assertEqual(Counted.counter, 0) + class E(D): + __slots__ = ['e'] + x = E() + x.a = Counted() + x.z = Counted() + x.e = Counted() + self.assertEqual(Counted.counter, 3) + del x + self.assertEqual(Counted.counter, 0) - global C1 - class C1(list): - def __new__(cls, a, b): - return super(C1, cls).__new__(cls) - def __getnewargs__(self): - return (self.a, self.b) - def __init__(self, a, b): - self.a = a - self.b = b - def __repr__(self): - return "C1(%r, %r)<%r>" % (self.a, self.b, list(self)) + # Test cyclical leaks [SF bug 519621] + class F(object): + __slots__ = ['a', 'b'] + log = [] + s = F() + s.a = [Counted(), s] + self.assertEqual(Counted.counter, 1) + s = None + import gc + gc.collect() + self.assertEqual(Counted.counter, 0) - global C2 - class C2(int): - def __new__(cls, a, b, val=0): - return super(C2, cls).__new__(cls, val) - def __getnewargs__(self): - return (self.a, self.b, int(self)) - def __init__(self, a, b, val=0): - self.a = a - self.b = b - def __repr__(self): - return "C2(%r, %r)<%r>" % (self.a, self.b, int(self)) + # Test lookup leaks [SF bug 572567] + import sys,gc + class G(object): + def __cmp__(self, other): + return 0 + g = G() + orig_objects = len(gc.get_objects()) + for i in range(10): + g==g + new_objects = len(gc.get_objects()) + self.assertEqual(orig_objects, new_objects) + class H(object): + __slots__ = ['a', 'b'] + def __init__(self): + self.a = 1 + self.b = 2 + def __del__(self_): + self.assertEqual(self_.a, 1) + self.assertEqual(self_.b, 2) - global C3 - class C3(object): - def __init__(self, foo): - self.foo = foo - def __getstate__(self): - return self.foo - def __setstate__(self, foo): - self.foo = foo + save_stderr = sys.stderr + sys.stderr = sys.stdout + h = H() + try: + del h + finally: + sys.stderr = save_stderr - global C4classic, C4 - class C4classic: # classic - pass - class C4(C4classic, object): # mixed inheritance - pass + def test_slots_special(self): + # Testing __dict__ and __weakref__ in __slots__... + class D(object): + __slots__ = ["__dict__"] + a = D() + self.assert_(hasattr(a, "__dict__")) + self.assertFalse(hasattr(a, "__weakref__")) + a.foo = 42 + self.assertEqual(a.__dict__, {"foo": 42}) + + class W(object): + __slots__ = ["__weakref__"] + a = W() + self.assert_(hasattr(a, "__weakref__")) + self.assertFalse(hasattr(a, "__dict__")) + try: + a.foo = 42 + except AttributeError: + pass + else: + self.fail("shouldn't be allowed to set a.foo") + + class C1(W, D): + __slots__ = [] + a = C1() + self.assert_(hasattr(a, "__dict__")) + self.assert_(hasattr(a, "__weakref__")) + a.foo = 42 + self.assertEqual(a.__dict__, {"foo": 42}) + + class C2(D, W): + __slots__ = [] + a = C2() + self.assert_(hasattr(a, "__dict__")) + self.assert_(hasattr(a, "__weakref__")) + a.foo = 42 + self.assertEqual(a.__dict__, {"foo": 42}) + + def test_dynamics(self): + # Testing class attribute propagation... + class D(object): + pass + class E(D): + pass + class F(D): + pass + D.foo = 1 + self.assertEqual(D.foo, 1) + # Test that dynamic attributes are inherited + self.assertEqual(E.foo, 1) + self.assertEqual(F.foo, 1) + # Test dynamic instances + class C(object): + pass + a = C() + self.assertFalse(hasattr(a, "foobar")) + C.foobar = 2 + self.assertEqual(a.foobar, 2) + C.method = lambda self: 42 + self.assertEqual(a.method(), 42) + C.__repr__ = lambda self: "C()" + self.assertEqual(repr(a), "C()") + C.__int__ = lambda self: 100 + self.assertEqual(int(a), 100) + self.assertEqual(a.foobar, 2) + self.assertFalse(hasattr(a, "spam")) + def mygetattr(self, name): + if name == "spam": + return "spam" + raise AttributeError + C.__getattr__ = mygetattr + self.assertEqual(a.spam, "spam") + a.new = 12 + self.assertEqual(a.new, 12) + def mysetattr(self, name, value): + if name == "spam": + raise AttributeError + return object.__setattr__(self, name, value) + C.__setattr__ = mysetattr + try: + a.spam = "not spam" + except AttributeError: + pass + else: + self.fail("expected AttributeError") + self.assertEqual(a.spam, "spam") + class D(C): + pass + d = D() + d.foo = 1 + self.assertEqual(d.foo, 1) + + # Test handling of int*seq and seq*int + class I(int): + pass + self.assertEqual("a"*I(2), "aa") + self.assertEqual(I(2)*"a", "aa") + self.assertEqual(2*I(3), 6) + self.assertEqual(I(3)*2, 6) + self.assertEqual(I(3)*I(2), 6) + + # Test handling of long*seq and seq*long + class L(int): + pass + self.assertEqual("a"*L(2), "aa") + self.assertEqual(L(2)*"a", "aa") + self.assertEqual(2*L(3), 6) + self.assertEqual(L(3)*2, 6) + self.assertEqual(L(3)*L(2), 6) + + # Test comparison of classes with dynamic metaclasses + class dynamicmetaclass(type): + pass + class someclass(metaclass=dynamicmetaclass): + pass + self.assertNotEqual(someclass, object) + + def test_errors(self): + # Testing errors... + try: + class C(list, dict): + pass + except TypeError: + pass + else: + self.fail("inheritance from both list and dict should be illegal") + + try: + class C(object, None): + pass + except TypeError: + pass + else: + self.fail("inheritance from non-type should be illegal") + class Classic: + pass + + try: + class C(type(len)): + pass + except TypeError: + pass + else: + self.fail("inheritance from CFunction should be illegal") + + try: + class C(object): + __slots__ = 1 + except TypeError: + pass + else: + self.fail("__slots__ = 1 should be illegal") + + try: + class C(object): + __slots__ = [1] + except TypeError: + pass + else: + self.fail("__slots__ = [1] should be illegal") + + class M1(type): + pass + class M2(type): + pass + class A1(object, metaclass=M1): + pass + class A2(object, metaclass=M2): + pass + try: + class B(A1, A2): + pass + except TypeError: + pass + else: + self.fail("finding the most derived metaclass should have failed") + + def test_classmethods(self): + # Testing class methods... + class C(object): + def foo(*a): return a + goo = classmethod(foo) + c = C() + self.assertEqual(C.goo(1), (C, 1)) + self.assertEqual(c.goo(1), (C, 1)) + self.assertEqual(c.foo(1), (c, 1)) + class D(C): + pass + d = D() + self.assertEqual(D.goo(1), (D, 1)) + self.assertEqual(d.goo(1), (D, 1)) + self.assertEqual(d.foo(1), (d, 1)) + self.assertEqual(D.foo(d, 1), (d, 1)) + # Test for a specific crash (SF bug 528132) + def f(cls, arg): return (cls, arg) + ff = classmethod(f) + self.assertEqual(ff.__get__(0, int)(42), (int, 42)) + self.assertEqual(ff.__get__(0)(42), (int, 42)) + + # Test super() with classmethods (SF bug 535444) + self.assertEqual(C.goo.__self__, C) + self.assertEqual(D.goo.__self__, D) + self.assertEqual(super(D,D).goo.__self__, D) + self.assertEqual(super(D,d).goo.__self__, D) + self.assertEqual(super(D,D).goo(), (D,)) + self.assertEqual(super(D,d).goo(), (D,)) + + # Verify that argument is checked for callability (SF bug 753451) + try: + classmethod(1).__get__(1) + except TypeError: + pass + else: + self.fail("classmethod should check for callability") + + # Verify that classmethod() doesn't allow keyword args + try: + classmethod(f, kw=1) + except TypeError: + pass + else: + self.fail("classmethod shouldn't accept keyword args") + + def test_classmethods_in_c(self): + # Testing C-based class methods... + import xxsubtype as spam + a = (1, 2, 3) + d = {'abc': 123} + x, a1, d1 = spam.spamlist.classmeth(*a, **d) + self.assertEqual(x, spam.spamlist) + self.assertEqual(a, a1) + self.assertEqual(d, d1) + x, a1, d1 = spam.spamlist().classmeth(*a, **d) + self.assertEqual(x, spam.spamlist) + self.assertEqual(a, a1) + self.assertEqual(d, d1) + + def test_staticmethods(self): + # Testing static methods... + class C(object): + def foo(*a): return a + goo = staticmethod(foo) + c = C() + self.assertEqual(C.goo(1), (1,)) + self.assertEqual(c.goo(1), (1,)) + self.assertEqual(c.foo(1), (c, 1,)) + class D(C): + pass + d = D() + self.assertEqual(D.goo(1), (1,)) + self.assertEqual(d.goo(1), (1,)) + self.assertEqual(d.foo(1), (d, 1)) + self.assertEqual(D.foo(d, 1), (d, 1)) + + def test_staticmethods_in_c(self): + # Testing C-based static methods... + import xxsubtype as spam + a = (1, 2, 3) + d = {"abc": 123} + x, a1, d1 = spam.spamlist.staticmeth(*a, **d) + self.assertEqual(x, None) + self.assertEqual(a, a1) + self.assertEqual(d, d1) + x, a1, d2 = spam.spamlist().staticmeth(*a, **d) + self.assertEqual(x, None) + self.assertEqual(a, a1) + self.assertEqual(d, d1) + + def test_classic(self): + # Testing classic classes... + class C: + def foo(*a): return a + goo = classmethod(foo) + c = C() + self.assertEqual(C.goo(1), (C, 1)) + self.assertEqual(c.goo(1), (C, 1)) + self.assertEqual(c.foo(1), (c, 1)) + class D(C): + pass + d = D() + self.assertEqual(D.goo(1), (D, 1)) + self.assertEqual(d.goo(1), (D, 1)) + self.assertEqual(d.foo(1), (d, 1)) + self.assertEqual(D.foo(d, 1), (d, 1)) + class E: # *not* subclassing from C + foo = C.foo + self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound + self.assert_(repr(C.foo.__get__(C())).startswith("= 0) + self.assertEqual(str(c1), repr(c1)) + self.assert_(-1 not in c1) + for i in range(10): + self.assert_(i in c1) + self.assertFalse(10 in c1) + # Test the default behavior for dynamic classes + class D(object): + def __getitem__(self, i): + if 0 <= i < 10: return i + raise IndexError + d1 = D() + d2 = D() + self.assert_(not not d1) + self.assertNotEqual(id(d1), id(d2)) + hash(d1) + hash(d2) + ## self.assertEqual(cmp(d1, d2), cmp(id(d1), id(d2))) + self.assertEqual(d1, d1) + self.assertNotEqual(d1, d2) + self.assert_(not d1 != d1) + self.assert_(not d1 == d2) + # Note that the module name appears in str/repr, and that varies + # depending on whether this test is run standalone or from a framework. + self.assert_(str(d1).find('D object at ') >= 0) + self.assertEqual(str(d1), repr(d1)) + self.assert_(-1 not in d1) + for i in range(10): + self.assert_(i in d1) + self.assertFalse(10 in d1) + # Test overridden behavior for static classes + class Proxy(object): + def __init__(self, x): + self.x = x + def __bool__(self): + return not not self.x + def __hash__(self): + return hash(self.x) + def __eq__(self, other): + return self.x == other + def __ne__(self, other): + return self.x != other + def __cmp__(self, other): + return cmp(self.x, other.x) + def __str__(self): + return "Proxy:%s" % self.x + def __repr__(self): + return "Proxy(%r)" % self.x + def __contains__(self, value): + return value in self.x + p0 = Proxy(0) + p1 = Proxy(1) + p_1 = Proxy(-1) + self.assertFalse(p0) + self.assert_(not not p1) + self.assertEqual(hash(p0), hash(0)) + self.assertEqual(p0, p0) + self.assertNotEqual(p0, p1) + self.assert_(not p0 != p0) + self.assertEqual(not p0, p1) + self.assertEqual(cmp(p0, p1), -1) + self.assertEqual(cmp(p0, p0), 0) + self.assertEqual(cmp(p0, p_1), 1) + self.assertEqual(str(p0), "Proxy:0") + self.assertEqual(repr(p0), "Proxy(0)") + p10 = Proxy(range(10)) + self.assertFalse(-1 in p10) + for i in range(10): + self.assert_(i in p10) + self.assertFalse(10 in p10) + # Test overridden behavior for dynamic classes + class DProxy(object): + def __init__(self, x): + self.x = x + def __bool__(self): + return not not self.x + def __hash__(self): + return hash(self.x) + def __eq__(self, other): + return self.x == other + def __ne__(self, other): + return self.x != other + def __cmp__(self, other): + return cmp(self.x, other.x) + def __str__(self): + return "DProxy:%s" % self.x + def __repr__(self): + return "DProxy(%r)" % self.x + def __contains__(self, value): + return value in self.x + p0 = DProxy(0) + p1 = DProxy(1) + p_1 = DProxy(-1) + self.assertFalse(p0) + self.assert_(not not p1) + self.assertEqual(hash(p0), hash(0)) + self.assertEqual(p0, p0) + self.assertNotEqual(p0, p1) + self.assertNotEqual(not p0, p0) + self.assertEqual(not p0, p1) + self.assertEqual(cmp(p0, p1), -1) + self.assertEqual(cmp(p0, p0), 0) + self.assertEqual(cmp(p0, p_1), 1) + self.assertEqual(str(p0), "DProxy:0") + self.assertEqual(repr(p0), "DProxy(0)") + p10 = DProxy(range(10)) + self.assertFalse(-1 in p10) + for i in range(10): + self.assert_(i in p10) + self.assertFalse(10 in p10) + + ## # Safety test for __cmp__ + ## def unsafecmp(a, b): + ## try: + ## a.__class__.__cmp__(a, b) + ## except TypeError: + ## pass + ## else: + ## self.fail("shouldn't allow %s.__cmp__(%r, %r)" % ( + ## a.__class__, a, b)) + ## + ## unsafecmp("123", "123") + ## unsafecmp("123", "123") + ## unsafecmp(1, 1.0) + ## unsafecmp(1.0, 1) + ## unsafecmp(1, 1) + ## unsafecmp(1, 1) + + def test_weakrefs(self): + # Testing weak references... + import weakref + class C(object): + pass + c = C() + r = weakref.ref(c) + self.assertEqual(r(), c) + del c + self.assertEqual(r(), None) + del r + class NoWeak(object): + __slots__ = ['foo'] + no = NoWeak() + try: + weakref.ref(no) + except TypeError as msg: + self.assert_(str(msg).find("weak reference") >= 0) + else: + self.fail("weakref.ref(no) should be illegal") + class Weak(object): + __slots__ = ['foo', '__weakref__'] + yes = Weak() + r = weakref.ref(yes) + self.assertEqual(r(), yes) + del yes + self.assertEqual(r(), None) + del r + + def test_properties(self): + # Testing property... + class C(object): + def getx(self): + return self.__x + def setx(self, value): + self.__x = value + def delx(self): + del self.__x + x = property(getx, setx, delx, doc="I'm the x property.") + a = C() + self.assertFalse(hasattr(a, "x")) + a.x = 42 + self.assertEqual(a._C__x, 42) + self.assertEqual(a.x, 42) + del a.x + self.assertFalse(hasattr(a, "x")) + self.assertFalse(hasattr(a, "_C__x")) + C.x.__set__(a, 100) + self.assertEqual(C.x.__get__(a), 100) + C.x.__delete__(a) + self.assertFalse(hasattr(a, "x")) + + raw = C.__dict__['x'] + self.assert_(isinstance(raw, property)) + + attrs = dir(raw) + self.assert_("__doc__" in attrs) + self.assert_("fget" in attrs) + self.assert_("fset" in attrs) + self.assert_("fdel" in attrs) + + self.assertEqual(raw.__doc__, "I'm the x property.") + self.assert_(raw.fget is C.__dict__['getx']) + self.assert_(raw.fset is C.__dict__['setx']) + self.assert_(raw.fdel is C.__dict__['delx']) + + for attr in "__doc__", "fget", "fset", "fdel": + try: + setattr(raw, attr, 42) + except AttributeError as msg: + if str(msg).find('readonly') < 0: + self.fail("when setting readonly attr %r on a property, " + "got unexpected AttributeError msg %r" % (attr, str(msg))) + else: + self.fail("expected AttributeError from trying to set readonly %r " + "attr on a property" % attr) + + class D(object): + __getitem__ = property(lambda s: 1/0) + + d = D() + try: + for i in d: + str(i) + except ZeroDivisionError: + pass + else: + self.fail("expected ZeroDivisionError from bad property") + + class E(object): + def getter(self): + "getter method" + return 0 + def setter(self_, value): + "setter method" + pass + prop = property(getter) + self.assertEqual(prop.__doc__, "getter method") + prop2 = property(fset=setter) + self.assertEqual(prop2.__doc__, None) + + # this segfaulted in 2.5b2 + try: + import _testcapi + except ImportError: + pass + else: + class X(object): + p = property(_testcapi.test_with_docstring) + + def test_properties_plus(self): + class C(object): + foo = property(doc="hello") + @foo.getter + def foo(self): + return self._foo + @foo.setter + def foo(self, value): + self._foo = abs(value) + @foo.deleter + def foo(self): + del self._foo + c = C() + self.assertEqual(C.foo.__doc__, "hello") + self.assertFalse(hasattr(c, "foo")) + c.foo = -42 + self.assert_(hasattr(c, '_foo')) + self.assertEqual(c._foo, 42) + self.assertEqual(c.foo, 42) + del c.foo + self.assertFalse(hasattr(c, '_foo')) + self.assertFalse(hasattr(c, "foo")) + + class D(C): + @C.foo.deleter + def foo(self): + try: + del self._foo + except AttributeError: + pass + d = D() + d.foo = 24 + self.assertEqual(d.foo, 24) + del d.foo + del d.foo + + class E(object): + @property + def foo(self): + return self._foo + @foo.setter + def foo(self, value): + raise RuntimeError + @foo.setter + def foo(self, value): + self._foo = abs(value) + @foo.deleter + def foo(self, value=None): + del self._foo + + e = E() + e.foo = -42 + self.assertEqual(e.foo, 42) + del e.foo + + class F(E): + @E.foo.deleter + def foo(self): + del self._foo + @foo.setter + def foo(self, value): + self._foo = max(0, value) + f = F() + f.foo = -10 + self.assertEqual(f.foo, 0) + del f.foo + + def test_dict_constructors(self): + # Testing dict constructor ... + d = dict() + self.assertEqual(d, {}) + d = dict({}) + self.assertEqual(d, {}) + d = dict({1: 2, 'a': 'b'}) + self.assertEqual(d, {1: 2, 'a': 'b'}) + self.assertEqual(d, dict(list(d.items()))) + self.assertEqual(d, dict(iter(d.items()))) + d = dict({'one':1, 'two':2}) + self.assertEqual(d, dict(one=1, two=2)) + self.assertEqual(d, dict(**d)) + self.assertEqual(d, dict({"one": 1}, two=2)) + self.assertEqual(d, dict([("two", 2)], one=1)) + self.assertEqual(d, dict([("one", 100), ("two", 200)], **d)) + self.assertEqual(d, dict(**d)) + + for badarg in 0, 0, 0j, "0", [0], (0,): + try: + dict(badarg) + except TypeError: + pass + except ValueError: + if badarg == "0": + # It's a sequence, and its elements are also sequences (gotta + # love strings ), but they aren't of length 2, so this + # one seemed better as a ValueError than a TypeError. + pass + else: + self.fail("no TypeError from dict(%r)" % badarg) + else: + self.fail("no TypeError from dict(%r)" % badarg) + + try: + dict({}, {}) + except TypeError: + pass + else: + self.fail("no TypeError from dict({}, {})") + + class Mapping: + # Lacks a .keys() method; will be added later. + dict = {1:2, 3:4, 'a':1j} + + try: + dict(Mapping()) + except TypeError: + pass + else: + self.fail("no TypeError from dict(incomplete mapping)") + + Mapping.keys = lambda self: list(self.dict.keys()) + Mapping.__getitem__ = lambda self, i: self.dict[i] + d = dict(Mapping()) + self.assertEqual(d, Mapping.dict) + + # Init from sequence of iterable objects, each producing a 2-sequence. + class AddressBookEntry: + def __init__(self, first, last): + self.first = first + self.last = last + def __iter__(self): + return iter([self.first, self.last]) + + d = dict([AddressBookEntry('Tim', 'Warsaw'), + AddressBookEntry('Barry', 'Peters'), + AddressBookEntry('Tim', 'Peters'), + AddressBookEntry('Barry', 'Warsaw')]) + self.assertEqual(d, {'Barry': 'Warsaw', 'Tim': 'Peters'}) + + d = dict(zip(range(4), range(1, 5))) + self.assertEqual(d, dict([(i, i+1) for i in range(4)])) + + # Bad sequence lengths. + for bad in [('tooshort',)], [('too', 'long', 'by 1')]: + try: + dict(bad) + except ValueError: + pass + else: + self.fail("no ValueError from dict(%r)" % bad) + + def test_dir(self): + # Testing dir() ... + junk = 12 + self.assertEqual(dir(), ['junk', 'self']) + del junk + + # Just make sure these don't blow up! + for arg in 2, 2, 2j, 2e0, [2], "2", b"2", (2,), {2:2}, type, self.test_dir: + dir(arg) + + # Test dir on new-style classes. Since these have object as a + # base class, a lot more gets sucked in. + def interesting(strings): + return [s for s in strings if not s.startswith('_')] + + class C(object): + Cdata = 1 + def Cmethod(self): pass + + cstuff = ['Cdata', 'Cmethod'] + self.assertEqual(interesting(dir(C)), cstuff) + + c = C() + self.assertEqual(interesting(dir(c)), cstuff) + ## self.assert_('__self__' in dir(C.Cmethod)) + + c.cdata = 2 + c.cmethod = lambda self: 0 + self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod']) + ## self.assert_('__self__' in dir(c.Cmethod)) + + class A(C): + Adata = 1 + def Amethod(self): pass + + astuff = ['Adata', 'Amethod'] + cstuff + self.assertEqual(interesting(dir(A)), astuff) + ## self.assert_('__self__' in dir(A.Amethod)) + a = A() + self.assertEqual(interesting(dir(a)), astuff) + a.adata = 42 + a.amethod = lambda self: 3 + self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod']) + ## self.assert_('__self__' in dir(a.Amethod)) + + # Try a module subclass. + import sys + class M(type(sys)): + pass + minstance = M("m") + minstance.b = 2 + minstance.a = 1 + names = [x for x in dir(minstance) if x not in ["__name__", "__doc__"]] + self.assertEqual(names, ['a', 'b']) + + class M2(M): + def getdict(self): + return "Not a dict!" + __dict__ = property(getdict) + + m2instance = M2("m2") + m2instance.b = 2 + m2instance.a = 1 + self.assertEqual(m2instance.__dict__, "Not a dict!") + try: + dir(m2instance) + except TypeError: + pass + + # Two essentially featureless objects, just inheriting stuff from + # object. + self.assertEqual(dir(None), dir(Ellipsis)) + + # Nasty test case for proxied objects + class Wrapper(object): + def __init__(self, obj): + self.__obj = obj + def __repr__(self): + return "Wrapper(%s)" % repr(self.__obj) + def __getitem__(self, key): + return Wrapper(self.__obj[key]) + def __len__(self): + return len(self.__obj) + def __getattr__(self, name): + return Wrapper(getattr(self.__obj, name)) + + class C(object): + def __getclass(self): + return Wrapper(type(self)) + __class__ = property(__getclass) + + dir(C()) # This used to segfault + + def test_supers(self): + # Testing super... + + class A(object): + def meth(self, a): + return "A(%r)" % a + + self.assertEqual(A().meth(1), "A(1)") + + class B(A): + def __init__(self): + self.__super = super(B, self) + def meth(self, a): + return "B(%r)" % a + self.__super.meth(a) + + self.assertEqual(B().meth(2), "B(2)A(2)") + + class C(A): + def meth(self, a): + return "C(%r)" % a + self.__super.meth(a) + C._C__super = super(C) + + self.assertEqual(C().meth(3), "C(3)A(3)") + + class D(C, B): + def meth(self, a): + return "D(%r)" % a + super(D, self).meth(a) + + self.assertEqual(D().meth(4), "D(4)C(4)B(4)A(4)") + + # Test for subclassing super + + class mysuper(super): + def __init__(self, *args): + return super(mysuper, self).__init__(*args) + + class E(D): + def meth(self, a): + return "E(%r)" % a + mysuper(E, self).meth(a) + + self.assertEqual(E().meth(5), "E(5)D(5)C(5)B(5)A(5)") + + class F(E): + def meth(self, a): + s = self.__super # == mysuper(F, self) + return "F(%r)[%s]" % (a, s.__class__.__name__) + s.meth(a) + F._F__super = mysuper(F) + + self.assertEqual(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)") + + # Make sure certain errors are raised + + try: + super(D, 42) + except TypeError: + pass + else: + self.fail("shouldn't allow super(D, 42)") + + try: + super(D, C()) + except TypeError: + pass + else: + self.fail("shouldn't allow super(D, C())") + + try: + super(D).__get__(12) + except TypeError: + pass + else: + self.fail("shouldn't allow super(D).__get__(12)") + + try: + super(D).__get__(C()) + except TypeError: + pass + else: + self.fail("shouldn't allow super(D).__get__(C())") + + # Make sure data descriptors can be overridden and accessed via super + # (new feature in Python 2.3) + + class DDbase(object): + def getx(self): return 42 + x = property(getx) + + class DDsub(DDbase): + def getx(self): return "hello" + x = property(getx) + + dd = DDsub() + self.assertEqual(dd.x, "hello") + self.assertEqual(super(DDsub, dd).x, 42) + + # Ensure that super() lookup of descriptor from classmethod + # works (SF ID# 743627) + + class Base(object): + aProp = property(lambda self: "foo") + + class Sub(Base): + @classmethod + def test(klass): + return super(Sub,klass).aProp + + self.assertEqual(Sub.test(), Base.aProp) + + # Verify that super() doesn't allow keyword args + try: + super(Base, kw=1) + except TypeError: + pass + else: + self.assertEqual("super shouldn't accept keyword args") + + def test_basic_inheritance(self): + # Testing inheritance from basic types... + + class hexint(int): + def __repr__(self): + return hex(self) + def __add__(self, other): + return hexint(int.__add__(self, other)) + # (Note that overriding __radd__ doesn't work, + # because the int type gets first dibs.) + self.assertEqual(repr(hexint(7) + 9), "0x10") + self.assertEqual(repr(hexint(1000) + 7), "0x3ef") + a = hexint(12345) + self.assertEqual(a, 12345) + self.assertEqual(int(a), 12345) + self.assert_(int(a).__class__ is int) + self.assertEqual(hash(a), hash(12345)) + self.assert_((+a).__class__ is int) + self.assert_((a >> 0).__class__ is int) + self.assert_((a << 0).__class__ is int) + self.assert_((hexint(0) << 12).__class__ is int) + self.assert_((hexint(0) >> 12).__class__ is int) + + class octlong(int): + __slots__ = [] + def __str__(self): + s = oct(self) + if s[-1] == 'L': + s = s[:-1] + return s + def __add__(self, other): + return self.__class__(super(octlong, self).__add__(other)) + __radd__ = __add__ + self.assertEqual(str(octlong(3) + 5), "0o10") + # (Note that overriding __radd__ here only seems to work + # because the example uses a short int left argument.) + self.assertEqual(str(5 + octlong(3000)), "0o5675") + a = octlong(12345) + self.assertEqual(a, 12345) + self.assertEqual(int(a), 12345) + self.assertEqual(hash(a), hash(12345)) + self.assert_(int(a).__class__ is int) + self.assert_((+a).__class__ is int) + self.assert_((-a).__class__ is int) + self.assert_((-octlong(0)).__class__ is int) + self.assert_((a >> 0).__class__ is int) + self.assert_((a << 0).__class__ is int) + self.assert_((a - 0).__class__ is int) + self.assert_((a * 1).__class__ is int) + self.assert_((a ** 1).__class__ is int) + self.assert_((a // 1).__class__ is int) + self.assert_((1 * a).__class__ is int) + self.assert_((a | 0).__class__ is int) + self.assert_((a ^ 0).__class__ is int) + self.assert_((a & -1).__class__ is int) + self.assert_((octlong(0) << 12).__class__ is int) + self.assert_((octlong(0) >> 12).__class__ is int) + self.assert_(abs(octlong(0)).__class__ is int) + + # Because octlong overrides __add__, we can't check the absence of +0 + # optimizations using octlong. + class longclone(int): + pass + a = longclone(1) + self.assert_((a + 0).__class__ is int) + self.assert_((0 + a).__class__ is int) + + # Check that negative clones don't segfault + a = longclone(-1) + self.assertEqual(a.__dict__, {}) + self.assertEqual(int(a), -1) # self.assert_ PyNumber_Long() copies the sign bit + + class precfloat(float): + __slots__ = ['prec'] + def __init__(self, value=0.0, prec=12): + self.prec = int(prec) + def __repr__(self): + return "%.*g" % (self.prec, self) + self.assertEqual(repr(precfloat(1.1)), "1.1") + a = precfloat(12345) + self.assertEqual(a, 12345.0) + self.assertEqual(float(a), 12345.0) + self.assert_(float(a).__class__ is float) + self.assertEqual(hash(a), hash(12345.0)) + self.assert_((+a).__class__ is float) + + class madcomplex(complex): + def __repr__(self): + return "%.17gj%+.17g" % (self.imag, self.real) + a = madcomplex(-3, 4) + self.assertEqual(repr(a), "4j-3") + base = complex(-3, 4) + self.assertEqual(base.__class__, complex) + self.assertEqual(a, base) + self.assertEqual(complex(a), base) + self.assertEqual(complex(a).__class__, complex) + a = madcomplex(a) # just trying another form of the constructor + self.assertEqual(repr(a), "4j-3") + self.assertEqual(a, base) + self.assertEqual(complex(a), base) + self.assertEqual(complex(a).__class__, complex) + self.assertEqual(hash(a), hash(base)) + self.assertEqual((+a).__class__, complex) + self.assertEqual((a + 0).__class__, complex) + self.assertEqual(a + 0, base) + self.assertEqual((a - 0).__class__, complex) + self.assertEqual(a - 0, base) + self.assertEqual((a * 1).__class__, complex) + self.assertEqual(a * 1, base) + self.assertEqual((a / 1).__class__, complex) + self.assertEqual(a / 1, base) + + class madtuple(tuple): + _rev = None + def rev(self): + if self._rev is not None: + return self._rev + L = list(self) + L.reverse() + self._rev = self.__class__(L) + return self._rev + a = madtuple((1,2,3,4,5,6,7,8,9,0)) + self.assertEqual(a, (1,2,3,4,5,6,7,8,9,0)) + self.assertEqual(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1))) + self.assertEqual(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0))) + for i in range(512): + t = madtuple(range(i)) + u = t.rev() + v = u.rev() + self.assertEqual(v, t) + a = madtuple((1,2,3,4,5)) + self.assertEqual(tuple(a), (1,2,3,4,5)) + self.assert_(tuple(a).__class__ is tuple) + self.assertEqual(hash(a), hash((1,2,3,4,5))) + self.assert_(a[:].__class__ is tuple) + self.assert_((a * 1).__class__ is tuple) + self.assert_((a * 0).__class__ is tuple) + self.assert_((a + ()).__class__ is tuple) + a = madtuple(()) + self.assertEqual(tuple(a), ()) + self.assert_(tuple(a).__class__ is tuple) + self.assert_((a + a).__class__ is tuple) + self.assert_((a * 0).__class__ is tuple) + self.assert_((a * 1).__class__ is tuple) + self.assert_((a * 2).__class__ is tuple) + self.assert_(a[:].__class__ is tuple) + + class madstring(str): + _rev = None + def rev(self): + if self._rev is not None: + return self._rev + L = list(self) + L.reverse() + self._rev = self.__class__("".join(L)) + return self._rev + s = madstring("abcdefghijklmnopqrstuvwxyz") + self.assertEqual(s, "abcdefghijklmnopqrstuvwxyz") + self.assertEqual(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba")) + self.assertEqual(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz")) + for i in range(256): + s = madstring("".join(map(chr, range(i)))) + t = s.rev() + u = t.rev() + self.assertEqual(u, s) + s = madstring("12345") + self.assertEqual(str(s), "12345") + self.assert_(str(s).__class__ is str) + + base = "\x00" * 5 + s = madstring(base) + self.assertEqual(s, base) + self.assertEqual(str(s), base) + self.assert_(str(s).__class__ is str) + self.assertEqual(hash(s), hash(base)) + self.assertEqual({s: 1}[base], 1) + self.assertEqual({base: 1}[s], 1) + self.assert_((s + "").__class__ is str) + self.assertEqual(s + "", base) + self.assert_(("" + s).__class__ is str) + self.assertEqual("" + s, base) + self.assert_((s * 0).__class__ is str) + self.assertEqual(s * 0, "") + self.assert_((s * 1).__class__ is str) + self.assertEqual(s * 1, base) + self.assert_((s * 2).__class__ is str) + self.assertEqual(s * 2, base + base) + self.assert_(s[:].__class__ is str) + self.assertEqual(s[:], base) + self.assert_(s[0:0].__class__ is str) + self.assertEqual(s[0:0], "") + self.assert_(s.strip().__class__ is str) + self.assertEqual(s.strip(), base) + self.assert_(s.lstrip().__class__ is str) + self.assertEqual(s.lstrip(), base) + self.assert_(s.rstrip().__class__ is str) + self.assertEqual(s.rstrip(), base) + identitytab = {} + self.assert_(s.translate(identitytab).__class__ is str) + self.assertEqual(s.translate(identitytab), base) + self.assert_(s.replace("x", "x").__class__ is str) + self.assertEqual(s.replace("x", "x"), base) + self.assert_(s.ljust(len(s)).__class__ is str) + self.assertEqual(s.ljust(len(s)), base) + self.assert_(s.rjust(len(s)).__class__ is str) + self.assertEqual(s.rjust(len(s)), base) + self.assert_(s.center(len(s)).__class__ is str) + self.assertEqual(s.center(len(s)), base) + self.assert_(s.lower().__class__ is str) + self.assertEqual(s.lower(), base) + + class madunicode(str): + _rev = None + def rev(self): + if self._rev is not None: + return self._rev + L = list(self) + L.reverse() + self._rev = self.__class__("".join(L)) + return self._rev + u = madunicode("ABCDEF") + self.assertEqual(u, "ABCDEF") + self.assertEqual(u.rev(), madunicode("FEDCBA")) + self.assertEqual(u.rev().rev(), madunicode("ABCDEF")) + base = "12345" + u = madunicode(base) + self.assertEqual(str(u), base) + self.assert_(str(u).__class__ is str) + self.assertEqual(hash(u), hash(base)) + self.assertEqual({u: 1}[base], 1) + self.assertEqual({base: 1}[u], 1) + self.assert_(u.strip().__class__ is str) + self.assertEqual(u.strip(), base) + self.assert_(u.lstrip().__class__ is str) + self.assertEqual(u.lstrip(), base) + self.assert_(u.rstrip().__class__ is str) + self.assertEqual(u.rstrip(), base) + self.assert_(u.replace("x", "x").__class__ is str) + self.assertEqual(u.replace("x", "x"), base) + self.assert_(u.replace("xy", "xy").__class__ is str) + self.assertEqual(u.replace("xy", "xy"), base) + self.assert_(u.center(len(u)).__class__ is str) + self.assertEqual(u.center(len(u)), base) + self.assert_(u.ljust(len(u)).__class__ is str) + self.assertEqual(u.ljust(len(u)), base) + self.assert_(u.rjust(len(u)).__class__ is str) + self.assertEqual(u.rjust(len(u)), base) + self.assert_(u.lower().__class__ is str) + self.assertEqual(u.lower(), base) + self.assert_(u.upper().__class__ is str) + self.assertEqual(u.upper(), base) + self.assert_(u.capitalize().__class__ is str) + self.assertEqual(u.capitalize(), base) + self.assert_(u.title().__class__ is str) + self.assertEqual(u.title(), base) + self.assert_((u + "").__class__ is str) + self.assertEqual(u + "", base) + self.assert_(("" + u).__class__ is str) + self.assertEqual("" + u, base) + self.assert_((u * 0).__class__ is str) + self.assertEqual(u * 0, "") + self.assert_((u * 1).__class__ is str) + self.assertEqual(u * 1, base) + self.assert_((u * 2).__class__ is str) + self.assertEqual(u * 2, base + base) + self.assert_(u[:].__class__ is str) + self.assertEqual(u[:], base) + self.assert_(u[0:0].__class__ is str) + self.assertEqual(u[0:0], "") + + class sublist(list): + pass + a = sublist(range(5)) + self.assertEqual(a, list(range(5))) + a.append("hello") + self.assertEqual(a, list(range(5)) + ["hello"]) + a[5] = 5 + self.assertEqual(a, list(range(6))) + a.extend(range(6, 20)) + self.assertEqual(a, list(range(20))) + a[-5:] = [] + self.assertEqual(a, list(range(15))) + del a[10:15] + self.assertEqual(len(a), 10) + self.assertEqual(a, list(range(10))) + self.assertEqual(list(a), list(range(10))) + self.assertEqual(a[0], 0) + self.assertEqual(a[9], 9) + self.assertEqual(a[-10], 0) + self.assertEqual(a[-1], 9) + self.assertEqual(a[:5], list(range(5))) + + ## class CountedInput(file): + ## """Counts lines read by self.readline(). + ## + ## self.lineno is the 0-based ordinal of the last line read, up to + ## a maximum of one greater than the number of lines in the file. + ## + ## self.ateof is true if and only if the final "" line has been read, + ## at which point self.lineno stops incrementing, and further calls + ## to readline() continue to return "". + ## """ + ## + ## lineno = 0 + ## ateof = 0 + ## def readline(self): + ## if self.ateof: + ## return "" + ## s = file.readline(self) + ## # Next line works too. + ## # s = super(CountedInput, self).readline() + ## self.lineno += 1 + ## if s == "": + ## self.ateof = 1 + ## return s + ## + ## f = file(name=test_support.TESTFN, mode='w') + ## lines = ['a\n', 'b\n', 'c\n'] + ## try: + ## f.writelines(lines) + ## f.close() + ## f = CountedInput(test_support.TESTFN) + ## for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]): + ## got = f.readline() + ## self.assertEqual(expected, got) + ## self.assertEqual(f.lineno, i) + ## self.assertEqual(f.ateof, (i > len(lines))) + ## f.close() + ## finally: + ## try: + ## f.close() + ## except: + ## pass + ## test_support.unlink(test_support.TESTFN) + + def test_keywords(self): + # Testing keyword args to basic type constructors ... + self.assertEqual(int(x=1), 1) + self.assertEqual(float(x=2), 2.0) + self.assertEqual(int(x=3), 3) + self.assertEqual(complex(imag=42, real=666), complex(666, 42)) + self.assertEqual(str(object=500), '500') + self.assertEqual(str(object=b'abc', errors='strict'), 'abc') + self.assertEqual(tuple(sequence=range(3)), (0, 1, 2)) + self.assertEqual(list(sequence=(0, 1, 2)), list(range(3))) + # note: as of Python 2.3, dict() no longer has an "items" keyword arg + + for constructor in (int, float, int, complex, str, str, + tuple, list): + try: + constructor(bogus_keyword_arg=1) + except TypeError: + pass + else: + self.fail("expected TypeError from bogus keyword argument to %r" + % constructor) + + def test_str_subclass_as_dict_key(self): + # Testing a str subclass used as dict key .. + + class cistr(str): + """Sublcass of str that computes __eq__ case-insensitively. + + Also computes a hash code of the string in canonical form. + """ + + def __init__(self, value): + self.canonical = value.lower() + self.hashcode = hash(self.canonical) + + def __eq__(self, other): + if not isinstance(other, cistr): + other = cistr(other) + return self.canonical == other.canonical + + def __hash__(self): + return self.hashcode + + self.assertEqual(cistr('ABC'), 'abc') + self.assertEqual('aBc', cistr('ABC')) + self.assertEqual(str(cistr('ABC')), 'ABC') + + d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3} + self.assertEqual(d[cistr('one')], 1) + self.assertEqual(d[cistr('tWo')], 2) + self.assertEqual(d[cistr('THrEE')], 3) + self.assert_(cistr('ONe') in d) + self.assertEqual(d.get(cistr('thrEE')), 3) + + def test_classic_comparisons(self): + # Testing classic comparisons... + class classic: + pass + + for base in (classic, int, object): + class C(base): + def __init__(self, value): + self.value = int(value) + def __eq__(self, other): + if isinstance(other, C): + return self.value == other.value + if isinstance(other, int) or isinstance(other, int): + return self.value == other + return NotImplemented + def __ne__(self, other): + if isinstance(other, C): + return self.value != other.value + if isinstance(other, int) or isinstance(other, int): + return self.value != other + return NotImplemented + def __lt__(self, other): + if isinstance(other, C): + return self.value < other.value + if isinstance(other, int) or isinstance(other, int): + return self.value < other + return NotImplemented + def __le__(self, other): + if isinstance(other, C): + return self.value <= other.value + if isinstance(other, int) or isinstance(other, int): + return self.value <= other + return NotImplemented + def __gt__(self, other): + if isinstance(other, C): + return self.value > other.value + if isinstance(other, int) or isinstance(other, int): + return self.value > other + return NotImplemented + def __ge__(self, other): + if isinstance(other, C): + return self.value >= other.value + if isinstance(other, int) or isinstance(other, int): + return self.value >= other + return NotImplemented + + c1 = C(1) + c2 = C(2) + c3 = C(3) + self.assertEqual(c1, 1) + c = {1: c1, 2: c2, 3: c3} + for x in 1, 2, 3: + for y in 1, 2, 3: + ## self.assert_(cmp(c[x], c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y)) + for op in "<", "<=", "==", "!=", ">", ">=": + self.assert_(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), + "x=%d, y=%d" % (x, y)) + ## self.assert_(cmp(c[x], y) == cmp(x, y), "x=%d, y=%d" % (x, y)) + ## self.assert_(cmp(x, c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y)) + + def test_rich_comparisons(self): + # Testing rich comparisons... + class Z(complex): + pass + z = Z(1) + self.assertEqual(z, 1+0j) + self.assertEqual(1+0j, z) + class ZZ(complex): + def __eq__(self, other): + try: + return abs(self - other) <= 1e-6 + except: + return NotImplemented + zz = ZZ(1.0000003) + self.assertEqual(zz, 1+0j) + self.assertEqual(1+0j, zz) + + class classic: + pass + for base in (classic, int, object, list): + class C(base): + def __init__(self, value): + self.value = int(value) + def __cmp__(self_, other): + self.fail("shouldn't call __cmp__") + def __eq__(self, other): + if isinstance(other, C): + return self.value == other.value + if isinstance(other, int) or isinstance(other, int): + return self.value == other + return NotImplemented + def __ne__(self, other): + if isinstance(other, C): + return self.value != other.value + if isinstance(other, int) or isinstance(other, int): + return self.value != other + return NotImplemented + def __lt__(self, other): + if isinstance(other, C): + return self.value < other.value + if isinstance(other, int) or isinstance(other, int): + return self.value < other + return NotImplemented + def __le__(self, other): + if isinstance(other, C): + return self.value <= other.value + if isinstance(other, int) or isinstance(other, int): + return self.value <= other + return NotImplemented + def __gt__(self, other): + if isinstance(other, C): + return self.value > other.value + if isinstance(other, int) or isinstance(other, int): + return self.value > other + return NotImplemented + def __ge__(self, other): + if isinstance(other, C): + return self.value >= other.value + if isinstance(other, int) or isinstance(other, int): + return self.value >= other + return NotImplemented + c1 = C(1) + c2 = C(2) + c3 = C(3) + self.assertEqual(c1, 1) + c = {1: c1, 2: c2, 3: c3} + for x in 1, 2, 3: + for y in 1, 2, 3: + for op in "<", "<=", "==", "!=", ">", ">=": + self.assert_(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), + "x=%d, y=%d" % (x, y)) + self.assert_(eval("c[x] %s y" % op) == eval("x %s y" % op), + "x=%d, y=%d" % (x, y)) + self.assert_(eval("x %s c[y]" % op) == eval("x %s y" % op), + "x=%d, y=%d" % (x, y)) + + def test_descrdoc(self): + # Testing descriptor doc strings... + from _fileio import _FileIO + def check(descr, what): + self.assertEqual(descr.__doc__, what) + check(_FileIO.closed, "True if the file is closed") # getset descriptor + check(complex.real, "the real part of a complex number") # member descriptor + + def test_doc_descriptor(self): + # Testing __doc__ descriptor... + # SF bug 542984 + class DocDescr(object): + def __get__(self, object, otype): + if object: + object = object.__class__.__name__ + ' instance' + if otype: + otype = otype.__name__ + return 'object=%s; type=%s' % (object, otype) + class OldClass: + __doc__ = DocDescr() + class NewClass(object): + __doc__ = DocDescr() + self.assertEqual(OldClass.__doc__, 'object=None; type=OldClass') + self.assertEqual(OldClass().__doc__, 'object=OldClass instance; type=OldClass') + self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass') + self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass') + + def test_set_class(self): + # Testing __class__ assignment... + class C(object): pass + class D(object): pass + class E(object): pass + class F(D, E): pass + for cls in C, D, E, F: + for cls2 in C, D, E, F: + x = cls() + x.__class__ = cls2 + self.assert_(x.__class__ is cls2) + x.__class__ = cls + self.assert_(x.__class__ is cls) + def cant(x, C): + try: + x.__class__ = C + except TypeError: + pass + else: + self.fail("shouldn't allow %r.__class__ = %r" % (x, C)) + try: + delattr(x, "__class__") + except TypeError: + pass + else: + self.fail("shouldn't allow del %r.__class__" % x) + cant(C(), list) + cant(list(), C) + cant(C(), 1) + cant(C(), object) + cant(object(), list) + cant(list(), object) + class Int(int): __slots__ = [] + cant(2, Int) + cant(Int(), int) + cant(True, int) + cant(2, bool) + o = object() + cant(o, type(1)) + cant(o, type(None)) + del o + class G(object): + __slots__ = ["a", "b"] + class H(object): + __slots__ = ["b", "a"] + class I(object): + __slots__ = ["a", "b"] + class J(object): + __slots__ = ["c", "b"] + class K(object): + __slots__ = ["a", "b", "d"] + class L(H): + __slots__ = ["e"] + class M(I): + __slots__ = ["e"] + class N(J): + __slots__ = ["__weakref__"] + class P(J): + __slots__ = ["__dict__"] + class Q(J): + pass + class R(J): + __slots__ = ["__dict__", "__weakref__"] + + for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)): + x = cls() + x.a = 1 + x.__class__ = cls2 + self.assert_(x.__class__ is cls2, + "assigning %r as __class__ for %r silently failed" % (cls2, x)) + self.assertEqual(x.a, 1) + x.__class__ = cls + self.assert_(x.__class__ is cls, + "assigning %r as __class__ for %r silently failed" % (cls, x)) + self.assertEqual(x.a, 1) + for cls in G, J, K, L, M, N, P, R, list, Int: + for cls2 in G, J, K, L, M, N, P, R, list, Int: + if cls is cls2: + continue + cant(cls(), cls2) + + def test_set_dict(self): + # Testing __dict__ assignment... + class C(object): pass + a = C() + a.__dict__ = {'b': 1} + self.assertEqual(a.b, 1) + def cant(x, dict): + try: + x.__dict__ = dict + except (AttributeError, TypeError): + pass + else: + self.fail("shouldn't allow %r.__dict__ = %r" % (x, dict)) + cant(a, None) + cant(a, []) + cant(a, 1) + del a.__dict__ # Deleting __dict__ is allowed + + class Base(object): + pass + def verify_dict_readonly(x): + """ + x has to be an instance of a class inheriting from Base. + """ + cant(x, {}) + try: + del x.__dict__ + except (AttributeError, TypeError): + pass + else: + self.fail("shouldn't allow del %r.__dict__" % x) + dict_descr = Base.__dict__["__dict__"] + try: + dict_descr.__set__(x, {}) + except (AttributeError, TypeError): + pass + else: + self.fail("dict_descr allowed access to %r's dict" % x) + + # Classes don't allow __dict__ assignment and have readonly dicts + class Meta1(type, Base): + pass + class Meta2(Base, type): + pass + class D(object, metaclass=Meta1): + pass + class E(object, metaclass=Meta2): + pass + for cls in C, D, E: + verify_dict_readonly(cls) + class_dict = cls.__dict__ + try: + class_dict["spam"] = "eggs" + except TypeError: + pass + else: + self.fail("%r's __dict__ can be modified" % cls) + + # Modules also disallow __dict__ assignment + class Module1(types.ModuleType, Base): + pass + class Module2(Base, types.ModuleType): + pass + for ModuleType in Module1, Module2: + mod = ModuleType("spam") + verify_dict_readonly(mod) + mod.__dict__["spam"] = "eggs" + + # Exception's __dict__ can be replaced, but not deleted + class Exception1(Exception, Base): + pass + class Exception2(Base, Exception): + pass + for ExceptionType in Exception, Exception1, Exception2: + e = ExceptionType() + e.__dict__ = {"a": 1} + self.assertEqual(e.a, 1) + try: + del e.__dict__ + except (TypeError, AttributeError): + pass + else: + self.fail("%r's __dict__ can be deleted" % e) + + def test_pickles(self): + # Testing pickling and copying new-style classes and objects... + import pickle + + def sorteditems(d): + L = list(d.items()) + L.sort() + return L + + global C + class C(object): + def __init__(self, a, b): + super(C, self).__init__() + self.a = a + self.b = b + def __repr__(self): + return "C(%r, %r)" % (self.a, self.b) + + global C1 + class C1(list): + def __new__(cls, a, b): + return super(C1, cls).__new__(cls) + def __getnewargs__(self): + return (self.a, self.b) + def __init__(self, a, b): + self.a = a + self.b = b + def __repr__(self): + return "C1(%r, %r)<%r>" % (self.a, self.b, list(self)) + + global C2 + class C2(int): + def __new__(cls, a, b, val=0): + return super(C2, cls).__new__(cls, val) + def __getnewargs__(self): + return (self.a, self.b, int(self)) + def __init__(self, a, b, val=0): + self.a = a + self.b = b + def __repr__(self): + return "C2(%r, %r)<%r>" % (self.a, self.b, int(self)) + + global C3 + class C3(object): + def __init__(self, foo): + self.foo = foo + def __getstate__(self): + return self.foo + def __setstate__(self, foo): + self.foo = foo + + global C4classic, C4 + class C4classic: # classic + pass + class C4(C4classic, object): # mixed inheritance + pass - for p in [pickle]: for bin in 0, 1: - if verbose: - print(p.__name__, ["text", "binary"][bin]) - for cls in C, C1, C2: - s = p.dumps(cls, bin) - cls2 = p.loads(s) - verify(cls2 is cls) + s = pickle.dumps(cls, bin) + cls2 = pickle.loads(s) + self.assert_(cls2 is cls) a = C1(1, 2); a.append(42); a.append(24) b = C2("hello", "world", 42) - s = p.dumps((a, b), bin) - x, y = p.loads(s) - vereq(x.__class__, a.__class__) - vereq(sorteditems(x.__dict__), sorteditems(a.__dict__)) - vereq(y.__class__, b.__class__) - vereq(sorteditems(y.__dict__), sorteditems(b.__dict__)) - vereq(repr(x), repr(a)) - vereq(repr(y), repr(b)) - if verbose: - print("a = x =", a) - print("b = y =", b) + s = pickle.dumps((a, b), bin) + x, y = pickle.loads(s) + self.assertEqual(x.__class__, a.__class__) + self.assertEqual(sorteditems(x.__dict__), sorteditems(a.__dict__)) + self.assertEqual(y.__class__, b.__class__) + self.assertEqual(sorteditems(y.__dict__), sorteditems(b.__dict__)) + self.assertEqual(repr(x), repr(a)) + self.assertEqual(repr(y), repr(b)) # Test for __getstate__ and __setstate__ on new style class u = C3(42) - s = p.dumps(u, bin) - v = p.loads(s) - veris(u.__class__, v.__class__) - vereq(u.foo, v.foo) + s = pickle.dumps(u, bin) + v = pickle.loads(s) + self.assertEqual(u.__class__, v.__class__) + self.assertEqual(u.foo, v.foo) # Test for picklability of hybrid class u = C4() u.foo = 42 - s = p.dumps(u, bin) - v = p.loads(s) - veris(u.__class__, v.__class__) - vereq(u.foo, v.foo) + s = pickle.dumps(u, bin) + v = pickle.loads(s) + self.assertEqual(u.__class__, v.__class__) + self.assertEqual(u.foo, v.foo) - # Testing copy.deepcopy() - if verbose: - print("deepcopy") - import copy - for cls in C, C1, C2: - cls2 = copy.deepcopy(cls) - verify(cls2 is cls) + # Testing copy.deepcopy() + import copy + for cls in C, C1, C2: + cls2 = copy.deepcopy(cls) + self.assert_(cls2 is cls) - a = C1(1, 2); a.append(42); a.append(24) - b = C2("hello", "world", 42) - x, y = copy.deepcopy((a, b)) - vereq(x.__class__, a.__class__) - vereq(sorteditems(x.__dict__), sorteditems(a.__dict__)) - vereq(y.__class__, b.__class__) - vereq(sorteditems(y.__dict__), sorteditems(b.__dict__)) - vereq(repr(x), repr(a)) - vereq(repr(y), repr(b)) - if verbose: - print("a = x =", a) - print("b = y =", b) + a = C1(1, 2); a.append(42); a.append(24) + b = C2("hello", "world", 42) + x, y = copy.deepcopy((a, b)) + self.assertEqual(x.__class__, a.__class__) + self.assertEqual(sorteditems(x.__dict__), sorteditems(a.__dict__)) + self.assertEqual(y.__class__, b.__class__) + self.assertEqual(sorteditems(y.__dict__), sorteditems(b.__dict__)) + self.assertEqual(repr(x), repr(a)) + self.assertEqual(repr(y), repr(b)) -def pickleslots(): - if verbose: print("Testing pickling of classes with __slots__ ...") - import pickle - # Pickling of classes with __slots__ but without __getstate__ should fail - # (when using protocols 0 or 1) - global B, C, D, E - class B(object): - pass - for base in [object, B]: - class C(base): - __slots__ = ['a'] - class D(C): + def test_pickle_slots(self): + # Testing pickling of classes with __slots__ ... + import pickle + # Pickling of classes with __slots__ but without __getstate__ should fail + # (if using protocol 0 or 1) + global B, C, D, E + class B(object): pass + for base in [object, B]: + class C(base): + __slots__ = ['a'] + class D(C): + pass + try: + pickle.dumps(C(), 0) + except TypeError: + pass + else: + self.fail("should fail: pickle C instance - %s" % base) + try: + pickle.dumps(C(), 0) + except TypeError: + pass + else: + self.fail("should fail: pickle D instance - %s" % base) + # Give C a nice generic __getstate__ and __setstate__ + class C(base): + __slots__ = ['a'] + def __getstate__(self): + try: + d = self.__dict__.copy() + except AttributeError: + d = {} + for cls in self.__class__.__mro__: + for sn in cls.__dict__.get('__slots__', ()): + try: + d[sn] = getattr(self, sn) + except AttributeError: + pass + return d + def __setstate__(self, d): + for k, v in list(d.items()): + setattr(self, k, v) + class D(C): + pass + # Now it should work + x = C() + y = pickle.loads(pickle.dumps(x)) + self.assertEqual(hasattr(y, 'a'), 0) + x.a = 42 + y = pickle.loads(pickle.dumps(x)) + self.assertEqual(y.a, 42) + x = D() + x.a = 42 + x.b = 100 + y = pickle.loads(pickle.dumps(x)) + self.assertEqual(y.a + y.b, 142) + # A subclass that adds a slot should also work + class E(C): + __slots__ = ['b'] + x = E() + x.a = 42 + x.b = "foo" + y = pickle.loads(pickle.dumps(x)) + self.assertEqual(y.a, x.a) + self.assertEqual(y.b, x.b) + + def test_binary_operator_override(self): + # Testing overrides of binary operations... + class I(int): + def __repr__(self): + return "I(%r)" % int(self) + def __add__(self, other): + return I(int(self) + int(other)) + __radd__ = __add__ + def __pow__(self, other, mod=None): + if mod is None: + return I(pow(int(self), int(other))) + else: + return I(pow(int(self), int(other), int(mod))) + def __rpow__(self, other, mod=None): + if mod is None: + return I(pow(int(other), int(self), mod)) + else: + return I(pow(int(other), int(self), int(mod))) + + self.assertEqual(repr(I(1) + I(2)), "I(3)") + self.assertEqual(repr(I(1) + 2), "I(3)") + self.assertEqual(repr(1 + I(2)), "I(3)") + self.assertEqual(repr(I(2) ** I(3)), "I(8)") + self.assertEqual(repr(2 ** I(3)), "I(8)") + self.assertEqual(repr(I(2) ** 3), "I(8)") + self.assertEqual(repr(pow(I(2), I(3), I(5))), "I(3)") + class S(str): + def __eq__(self, other): + return self.lower() == other.lower() + + def test_subclass_propagation(self): + # Testing propagation of slot functions to subclasses... + class A(object): + pass + class B(A): + pass + class C(A): + pass + class D(B, C): + pass + d = D() + orig_hash = hash(d) # related to id(d) in platform-dependent ways + A.__hash__ = lambda self: 42 + self.assertEqual(hash(d), 42) + C.__hash__ = lambda self: 314 + self.assertEqual(hash(d), 314) + B.__hash__ = lambda self: 144 + self.assertEqual(hash(d), 144) + D.__hash__ = lambda self: 100 + self.assertEqual(hash(d), 100) + del D.__hash__ + self.assertEqual(hash(d), 144) + del B.__hash__ + self.assertEqual(hash(d), 314) + del C.__hash__ + self.assertEqual(hash(d), 42) + del A.__hash__ + self.assertEqual(hash(d), orig_hash) + d.foo = 42 + d.bar = 42 + self.assertEqual(d.foo, 42) + self.assertEqual(d.bar, 42) + def __getattribute__(self, name): + if name == "foo": + return 24 + return object.__getattribute__(self, name) + A.__getattribute__ = __getattribute__ + self.assertEqual(d.foo, 24) + self.assertEqual(d.bar, 42) + def __getattr__(self, name): + if name in ("spam", "foo", "bar"): + return "hello" + raise AttributeError(name) + B.__getattr__ = __getattr__ + self.assertEqual(d.spam, "hello") + self.assertEqual(d.foo, 24) + self.assertEqual(d.bar, 42) + del A.__getattribute__ + self.assertEqual(d.foo, 42) + del d.foo + self.assertEqual(d.foo, "hello") + self.assertEqual(d.bar, 42) + del B.__getattr__ try: - pickle.dumps(C(), 0) + d.foo + except AttributeError: + pass + else: + self.fail("d.foo should be undefined now") + + # Test a nasty bug in recurse_down_subclasses() + import gc + class A(object): + pass + class B(A): + pass + del B + gc.collect() + A.__setitem__ = lambda *a: None # crash + + def test_buffer_inheritance(self): + # Testing that buffer interface is inherited ... + + import binascii + # SF bug [#470040] ParseTuple t# vs subclasses. + + class MyStr(str): + pass + base = 'abc' + m = MyStr(base) + # b2a_hex uses the buffer interface to get its argument's value, via + # PyArg_ParseTuple 't#' code. + self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base)) + + # It's not clear that unicode will continue to support the character + # buffer interface, and this test will fail if that's taken away. + class MyUni(str): + pass + base = 'abc' + m = MyUni(base) + self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base)) + + class MyInt(int): + pass + m = MyInt(42) + try: + binascii.b2a_hex(m) + self.fail('subclass of int should not have a buffer interface') + except TypeError: + pass + + def test_str_of_str_subclass(self): + # Testing __str__ defined in subclass of str ... + import binascii + import io + + class octetstring(str): + def __str__(self): + return binascii.b2a_hex(self).decode("ascii") + def __repr__(self): + return self + " repr" + + o = octetstring('A') + self.assertEqual(type(o), octetstring) + self.assertEqual(type(str(o)), str) + self.assertEqual(type(repr(o)), str) + self.assertEqual(ord(o), 0x41) + self.assertEqual(str(o), '41') + self.assertEqual(repr(o), 'A repr') + self.assertEqual(o.__str__(), '41') + self.assertEqual(o.__repr__(), 'A repr') + + capture = io.StringIO() + # Calling str() or not exercises different internal paths. + print(o, file=capture) + print(str(o), file=capture) + self.assertEqual(capture.getvalue(), '41\n41\n') + capture.close() + + def test_keyword_arguments(self): + # Testing keyword arguments to __init__, __call__... + def f(a): return a + self.assertEqual(f.__call__(a=42), 42) + a = [] + list.__init__(a, sequence=[0, 1, 2]) + self.assertEqual(a, [0, 1, 2]) + + def test_recursive_call(self): + # Testing recursive __call__() by setting to instance of class... + class A(object): + pass + + A.__call__ = A() + try: + A()() + except RuntimeError: + pass + else: + self.fail("Recursion limit should have been reached for __call__()") + + def test_delete_hook(self): + # Testing __del__ hook... + log = [] + class C(object): + def __del__(self): + log.append(1) + c = C() + self.assertEqual(log, []) + del c + self.assertEqual(log, [1]) + + class D(object): pass + d = D() + try: del d[0] + except TypeError: pass + else: self.fail("invalid del() didn't raise TypeError") + + def test_hash_inheritance(self): + # Testing hash of mutable subclasses... + + class mydict(dict): + pass + d = mydict() + try: + hash(d) except TypeError: pass else: - raise TestFailed("should fail: pickle C instance - %s" % base) + self.fail("hash() of dict subclass should fail") + + class mylist(list): + pass + d = mylist() try: - pickle.dumps(C(), 0) + hash(d) except TypeError: pass else: - raise TestFailed("should fail: pickle D instance - %s" % base) - # Give C a nice generic __getstate__ and __setstate__ - class C(base): - __slots__ = ['a'] - def __getstate__(self): - try: - d = self.__dict__.copy() - except AttributeError: - d = {} - for cls in self.__class__.__mro__: - for sn in cls.__dict__.get('__slots__', ()): - try: - d[sn] = getattr(self, sn) - except AttributeError: - pass - return d - def __setstate__(self, d): - for k, v in d.items(): - setattr(self, k, v) - class D(C): + self.fail("hash() of list subclass should fail") + + def test_str_operations(self): + try: 'a' + 5 + except TypeError: pass + else: self.fail("'' + 5 doesn't raise TypeError") + + try: ''.split('') + except ValueError: pass + else: self.fail("''.split('') doesn't raise ValueError") + + try: ''.join([0]) + except TypeError: pass + else: self.fail("''.join([0]) doesn't raise TypeError") + + try: ''.rindex('5') + except ValueError: pass + else: self.fail("''.rindex('5') doesn't raise ValueError") + + try: '%(n)s' % None + except TypeError: pass + else: self.fail("'%(n)s' % None doesn't raise TypeError") + + try: '%(n' % {} + except ValueError: pass + else: self.fail("'%(n' % {} '' doesn't raise ValueError") + + try: '%*s' % ('abc') + except TypeError: pass + else: self.fail("'%*s' % ('abc') doesn't raise TypeError") + + try: '%*.*s' % ('abc', 5) + except TypeError: pass + else: self.fail("'%*.*s' % ('abc', 5) doesn't raise TypeError") + + try: '%s' % (1, 2) + except TypeError: pass + else: self.fail("'%s' % (1, 2) doesn't raise TypeError") + + try: '%' % None + except ValueError: pass + else: self.fail("'%' % None doesn't raise ValueError") + + self.assertEqual('534253'.isdigit(), 1) + self.assertEqual('534253x'.isdigit(), 0) + self.assertEqual('%c' % 5, '\x05') + self.assertEqual('%c' % '5', '5') + + def test_deepcopy_recursive(self): + # Testing deepcopy of recursive objects... + class Node: pass - # Now it should work + a = Node() + b = Node() + a.b = b + b.a = a + z = deepcopy(a) # This blew up before + + def test_unintialized_modules(self): + # Testing uninitialized module objects... + from types import ModuleType as M + m = M.__new__(M) + str(m) + self.assertEqual(hasattr(m, "__name__"), 0) + self.assertEqual(hasattr(m, "__file__"), 0) + self.assertEqual(hasattr(m, "foo"), 0) + self.assertEqual(m.__dict__, None) + m.foo = 1 + self.assertEqual(m.__dict__, {"foo": 1}) + + def test_funny_new(self): + # Testing __new__ returning something unexpected... + class C(object): + def __new__(cls, arg): + if isinstance(arg, str): return [1, 2, 3] + elif isinstance(arg, int): return object.__new__(D) + else: return object.__new__(cls) + class D(C): + def __init__(self, arg): + self.foo = arg + self.assertEqual(C("1"), [1, 2, 3]) + self.assertEqual(D("1"), [1, 2, 3]) + d = D(None) + self.assertEqual(d.foo, None) + d = C(1) + self.assertEqual(isinstance(d, D), True) + self.assertEqual(d.foo, 1) + d = D(1) + self.assertEqual(isinstance(d, D), True) + self.assertEqual(d.foo, 1) + + def test_imul_bug(self): + # Testing for __imul__ problems... + # SF bug 544647 + class C(object): + def __imul__(self, other): + return (self, other) x = C() - y = pickle.loads(pickle.dumps(x)) - vereq(hasattr(y, 'a'), 0) - x.a = 42 - y = pickle.loads(pickle.dumps(x)) - vereq(y.a, 42) - x = D() - x.a = 42 - x.b = 100 - y = pickle.loads(pickle.dumps(x)) - vereq(y.a + y.b, 142) - # A subclass that adds a slot should also work - class E(C): - __slots__ = ['b'] - x = E() - x.a = 42 - x.b = "foo" - y = pickle.loads(pickle.dumps(x)) - vereq(y.a, x.a) - vereq(y.b, x.b) + y = x + y *= 1.0 + self.assertEqual(y, (x, 1.0)) + y = x + y *= 2 + self.assertEqual(y, (x, 2)) + y = x + y *= 3 + self.assertEqual(y, (x, 3)) + y = x + y *= 1<<100 + self.assertEqual(y, (x, 1<<100)) + y = x + y *= None + self.assertEqual(y, (x, None)) + y = x + y *= "foo" + self.assertEqual(y, (x, "foo")) -def copies(): - if verbose: print("Testing copy.copy() and copy.deepcopy()...") - import copy - class C(object): - pass + def test_copy_setstate(self): + # Testing that copy.*copy() correctly uses __setstate__... + import copy + class C(object): + def __init__(self, foo=None): + self.foo = foo + self.__foo = foo + def setfoo(self, foo=None): + self.foo = foo + def getfoo(self): + return self.__foo + def __getstate__(self): + return [self.foo] + def __setstate__(self_, lst): + self.assertEqual(len(lst), 1) + self_.__foo = self_.foo = lst[0] + a = C(42) + a.setfoo(24) + self.assertEqual(a.foo, 24) + self.assertEqual(a.getfoo(), 42) + b = copy.copy(a) + self.assertEqual(b.foo, 24) + self.assertEqual(b.getfoo(), 24) + b = copy.deepcopy(a) + self.assertEqual(b.foo, 24) + self.assertEqual(b.getfoo(), 24) - a = C() - a.foo = 12 - b = copy.copy(a) - vereq(b.__dict__, a.__dict__) + def test_slices(self): + # Testing cases with slices and overridden __getitem__ ... - a.bar = [1,2,3] - c = copy.copy(a) - vereq(c.bar, a.bar) - verify(c.bar is a.bar) + # Strings + self.assertEqual("hello"[:4], "hell") + self.assertEqual("hello"[slice(4)], "hell") + self.assertEqual(str.__getitem__("hello", slice(4)), "hell") + class S(str): + def __getitem__(self, x): + return str.__getitem__(self, x) + self.assertEqual(S("hello")[:4], "hell") + self.assertEqual(S("hello")[slice(4)], "hell") + self.assertEqual(S("hello").__getitem__(slice(4)), "hell") + # Tuples + self.assertEqual((1,2,3)[:2], (1,2)) + self.assertEqual((1,2,3)[slice(2)], (1,2)) + self.assertEqual(tuple.__getitem__((1,2,3), slice(2)), (1,2)) + class T(tuple): + def __getitem__(self, x): + return tuple.__getitem__(self, x) + self.assertEqual(T((1,2,3))[:2], (1,2)) + self.assertEqual(T((1,2,3))[slice(2)], (1,2)) + self.assertEqual(T((1,2,3)).__getitem__(slice(2)), (1,2)) + # Lists + self.assertEqual([1,2,3][:2], [1,2]) + self.assertEqual([1,2,3][slice(2)], [1,2]) + self.assertEqual(list.__getitem__([1,2,3], slice(2)), [1,2]) + class L(list): + def __getitem__(self, x): + return list.__getitem__(self, x) + self.assertEqual(L([1,2,3])[:2], [1,2]) + self.assertEqual(L([1,2,3])[slice(2)], [1,2]) + self.assertEqual(L([1,2,3]).__getitem__(slice(2)), [1,2]) + # Now do lists and __setitem__ + a = L([1,2,3]) + a[slice(1, 3)] = [3,2] + self.assertEqual(a, [1,3,2]) + a[slice(0, 2, 1)] = [3,1] + self.assertEqual(a, [3,1,2]) + a.__setitem__(slice(1, 3), [2,1]) + self.assertEqual(a, [3,2,1]) + a.__setitem__(slice(0, 2, 1), [2,3]) + self.assertEqual(a, [2,3,1]) - d = copy.deepcopy(a) - vereq(d.__dict__, a.__dict__) - a.bar.append(4) - vereq(d.bar, [1,2,3]) + def test_subtype_resurrection(self): + # Testing resurrection of new-style instance... -def binopoverride(): - if verbose: print("Testing overrides of binary operations...") - class I(int): - def __repr__(self): - return "I(%r)" % int(self) - def __add__(self, other): - return I(int(self) + int(other)) - __radd__ = __add__ - def __pow__(self, other, mod=None): - if mod is None: - return I(pow(int(self), int(other))) - else: - return I(pow(int(self), int(other), int(mod))) - def __rpow__(self, other, mod=None): - if mod is None: - return I(pow(int(other), int(self), mod)) - else: - return I(pow(int(other), int(self), int(mod))) + class C(object): + container = [] - vereq(repr(I(1) + I(2)), "I(3)") - vereq(repr(I(1) + 2), "I(3)") - vereq(repr(1 + I(2)), "I(3)") - vereq(repr(I(2) ** I(3)), "I(8)") - vereq(repr(2 ** I(3)), "I(8)") - vereq(repr(I(2) ** 3), "I(8)") - vereq(repr(pow(I(2), I(3), I(5))), "I(3)") - class S(str): - def __eq__(self, other): - return self.lower() == other.lower() + def __del__(self): + # resurrect the instance + C.container.append(self) -def subclasspropagation(): - if verbose: print("Testing propagation of slot functions to subclasses...") - class A(object): - pass - class B(A): - pass - class C(A): - pass - class D(B, C): - pass - d = D() - orig_hash = hash(d) # related to id(d) in platform-dependent ways - A.__hash__ = lambda self: 42 - vereq(hash(d), 42) - C.__hash__ = lambda self: 314 - vereq(hash(d), 314) - B.__hash__ = lambda self: 144 - vereq(hash(d), 144) - D.__hash__ = lambda self: 100 - vereq(hash(d), 100) - del D.__hash__ - vereq(hash(d), 144) - del B.__hash__ - vereq(hash(d), 314) - del C.__hash__ - vereq(hash(d), 42) - del A.__hash__ - vereq(hash(d), orig_hash) - d.foo = 42 - d.bar = 42 - vereq(d.foo, 42) - vereq(d.bar, 42) - def __getattribute__(self, name): - if name == "foo": - return 24 - return object.__getattribute__(self, name) - A.__getattribute__ = __getattribute__ - vereq(d.foo, 24) - vereq(d.bar, 42) - def __getattr__(self, name): - if name in ("spam", "foo", "bar"): - return "hello" - raise AttributeError(name) - B.__getattr__ = __getattr__ - vereq(d.spam, "hello") - vereq(d.foo, 24) - vereq(d.bar, 42) - del A.__getattribute__ - vereq(d.foo, 42) - del d.foo - vereq(d.foo, "hello") - vereq(d.bar, 42) - del B.__getattr__ - try: - d.foo - except AttributeError: - pass - else: - raise TestFailed("d.foo should be undefined now") + c = C() + c.attr = 42 - # Test a nasty bug in recurse_down_subclasses() - import gc - class A(object): - pass - class B(A): - pass - del B - gc.collect() - A.__setitem__ = lambda *a: None # crash + # The most interesting thing here is whether this blows up, due to flawed + # GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1 bug). + del c -def buffer_inherit(): - import binascii - # SF bug [#470040] ParseTuple t# vs subclasses. - if verbose: - print("Testing that buffer interface is inherited ...") + # If that didn't blow up, it's also interesting to see whether clearing + # the last container slot works: that will attempt to delete c again, + # which will cause c to get appended back to the container again "during" + # the del. + del C.container[-1] + self.assertEqual(len(C.container), 1) + self.assertEqual(C.container[-1].attr, 42) - class MyStr(str): - pass - base = 'abc' - m = MyStr(base) - # b2a_hex uses the buffer interface to get its argument's value, via - # PyArg_ParseTuple 't#' code. - vereq(binascii.b2a_hex(m), binascii.b2a_hex(base)) + # Make c mortal again, so that the test framework with -l doesn't report + # it as a leak. + del C.__del__ - # It's not clear that unicode will continue to support the character - # buffer interface, and this test will fail if that's taken away. - class MyUni(str): - pass - base = 'abc' - m = MyUni(base) - vereq(binascii.b2a_hex(m), binascii.b2a_hex(base)) + def test_slots_trash(self): + # Testing slot trash... + # Deallocating deeply nested slotted trash caused stack overflows + class trash(object): + __slots__ = ['x'] + def __init__(self, x): + self.x = x + o = None + for i in range(50000): + o = trash(o) + del o - class MyInt(int): - pass - m = MyInt(42) - try: - binascii.b2a_hex(m) - raise TestFailed('subclass of int should not have a buffer interface') - except TypeError: - pass - -def str_of_str_subclass(): - import binascii - import io - - if verbose: - print("Testing __str__ defined in subclass of str ...") - - class octetstring(str): - def __str__(self): - return binascii.b2a_hex(self).decode("ascii") - def __repr__(self): - return self + " repr" - - o = octetstring('A') - vereq(type(o), octetstring) - vereq(type(str(o)), str) - vereq(type(repr(o)), str) - vereq(ord(o), 0x41) - vereq(str(o), '41') - vereq(repr(o), 'A repr') - vereq(o.__str__(), '41') - vereq(o.__repr__(), 'A repr') - - capture = io.StringIO() - # Calling str() or not exercises different internal paths. - print(o, file=capture) - print(str(o), file=capture) - vereq(capture.getvalue(), '41\n41\n') - capture.close() - -def kwdargs(): - if verbose: print("Testing keyword arguments to __init__, __call__...") - def f(a): return a - vereq(f.__call__(a=42), 42) - a = [] - list.__init__(a, sequence=[0, 1, 2]) - vereq(a, [0, 1, 2]) - -def recursive__call__(): - if verbose: print(("Testing recursive __call__() by setting to instance of " - "class ...")) - class A(object): - pass - - A.__call__ = A() - try: - A()() - except RuntimeError: - pass - else: - raise TestFailed("Recursion limit should have been reached for " - "__call__()") - -def delhook(): - if verbose: print("Testing __del__ hook...") - log = [] - class C(object): - def __del__(self): - log.append(1) - c = C() - vereq(log, []) - del c - vereq(log, [1]) - - class D(object): pass - d = D() - try: del d[0] - except TypeError: pass - else: raise TestFailed("invalid del() didn't raise TypeError") - -def hashinherit(): - if verbose: print("Testing hash of mutable subclasses...") - - class mydict(dict): - pass - d = mydict() - try: - hash(d) - except TypeError: - pass - else: - raise TestFailed("hash() of dict subclass should fail") - - class mylist(list): - pass - d = mylist() - try: - hash(d) - except TypeError: - pass - else: - raise TestFailed("hash() of list subclass should fail") - -def strops(): - try: 'a' + 5 - except TypeError: pass - else: raise TestFailed("'' + 5 doesn't raise TypeError") - - try: ''.split('') - except ValueError: pass - else: raise TestFailed("''.split('') doesn't raise ValueError") - - try: ''.rindex('5') - except ValueError: pass - else: raise TestFailed("''.rindex('5') doesn't raise ValueError") - - try: '%(n)s' % None - except TypeError: pass - else: raise TestFailed("'%(n)s' % None doesn't raise TypeError") - - try: '%(n' % {} - except ValueError: pass - else: raise TestFailed("'%(n' % {} '' doesn't raise ValueError") - - try: '%*s' % ('abc') - except TypeError: pass - else: raise TestFailed("'%*s' % ('abc') doesn't raise TypeError") - - try: '%*.*s' % ('abc', 5) - except TypeError: pass - else: raise TestFailed("'%*.*s' % ('abc', 5) doesn't raise TypeError") - - try: '%s' % (1, 2) - except TypeError: pass - else: raise TestFailed("'%s' % (1, 2) doesn't raise TypeError") - - try: '%' % None - except ValueError: pass - else: raise TestFailed("'%' % None doesn't raise ValueError") - - vereq('534253'.isdigit(), 1) - vereq('534253x'.isdigit(), 0) - vereq('%c' % 5, '\x05') - vereq('%c' % '5', '5') - -def deepcopyrecursive(): - if verbose: print("Testing deepcopy of recursive objects...") - class Node: - pass - a = Node() - b = Node() - a.b = b - b.a = a - z = deepcopy(a) # This blew up before - -def modules(): - if verbose: print("Testing uninitialized module objects...") - from types import ModuleType as M - m = M.__new__(M) - str(m) - vereq(hasattr(m, "__name__"), 0) - vereq(hasattr(m, "__file__"), 0) - vereq(hasattr(m, "foo"), 0) - vereq(m.__dict__, None) - m.foo = 1 - vereq(m.__dict__, {"foo": 1}) - -def dictproxyiterkeys(): - class C(object): - def meth(self): + def test_slots_multiple_inheritance(self): + # SF bug 575229, multiple inheritance w/ slots dumps core + class A(object): + __slots__=() + class B(object): pass - if verbose: print("Testing dict-proxy iterkeys...") - keys = [ key for key in C.__dict__.keys() ] - keys.sort() - vereq(keys, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth']) + class C(A,B) : + __slots__=() + self.assertEqual(C.__basicsize__, B.__basicsize__) + self.assert_(hasattr(C, '__dict__')) + self.assert_(hasattr(C, '__weakref__')) + C().x = 2 -def dictproxyitervalues(): - class C(object): - def meth(self): + def test_rmul(self): + # Testing correct invocation of __rmul__... + # SF patch 592646 + class C(object): + def __mul__(self, other): + return "mul" + def __rmul__(self, other): + return "rmul" + a = C() + self.assertEqual(a*2, "mul") + self.assertEqual(a*2.2, "mul") + self.assertEqual(2*a, "rmul") + self.assertEqual(2.2*a, "rmul") + + def test_ipow(self): + # Testing correct invocation of __ipow__... + # [SF bug 620179] + class C(object): + def __ipow__(self, other): + pass + a = C() + a **= 2 + + def test_mutable_bases(self): + # Testing mutable bases... + + # stuff that should work: + class C(object): pass - if verbose: print("Testing dict-proxy itervalues...") - values = [ values for values in C.__dict__.values() ] - vereq(len(values), 5) - -def dictproxyiteritems(): - class C(object): - def meth(self): + class C2(object): + def __getattribute__(self, attr): + if attr == 'a': + return 2 + else: + return super(C2, self).__getattribute__(attr) + def meth(self): + return 1 + class D(C): pass - if verbose: print("Testing dict-proxy iteritems...") - keys = [ key for (key, value) in C.__dict__.items() ] - keys.sort() - vereq(keys, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth']) - -def funnynew(): - if verbose: print("Testing __new__ returning something unexpected...") - class C(object): - def __new__(cls, arg): - if isinstance(arg, str): return [1, 2, 3] - elif isinstance(arg, int): return object.__new__(D) - else: return object.__new__(cls) - class D(C): - def __init__(self, arg): - self.foo = arg - vereq(C("1"), [1, 2, 3]) - vereq(D("1"), [1, 2, 3]) - d = D(None) - veris(d.foo, None) - d = C(1) - vereq(isinstance(d, D), True) - vereq(d.foo, 1) - d = D(1) - vereq(isinstance(d, D), True) - vereq(d.foo, 1) - -def imulbug(): - # SF bug 544647 - if verbose: print("Testing for __imul__ problems...") - class C(object): - def __imul__(self, other): - return (self, other) - x = C() - y = x - y *= 1.0 - vereq(y, (x, 1.0)) - y = x - y *= 2 - vereq(y, (x, 2)) - y = x - y *= 3 - vereq(y, (x, 3)) - y = x - y *= 1<<100 - vereq(y, (x, 1<<100)) - y = x - y *= None - vereq(y, (x, None)) - y = x - y *= "foo" - vereq(y, (x, "foo")) - -def docdescriptor(): - # SF bug 542984 - if verbose: print("Testing __doc__ descriptor...") - class DocDescr(object): - def __get__(self, object, otype): - if object: - object = object.__class__.__name__ + ' instance' - if otype: - otype = otype.__name__ - return 'object=%s; type=%s' % (object, otype) - class OldClass: - __doc__ = DocDescr() - class NewClass(object): - __doc__ = DocDescr() - vereq(OldClass.__doc__, 'object=None; type=OldClass') - vereq(OldClass().__doc__, 'object=OldClass instance; type=OldClass') - vereq(NewClass.__doc__, 'object=None; type=NewClass') - vereq(NewClass().__doc__, 'object=NewClass instance; type=NewClass') - -def copy_setstate(): - if verbose: - print("Testing that copy.*copy() correctly uses __setstate__...") - import copy - class C(object): - def __init__(self, foo=None): - self.foo = foo - self.__foo = foo - def setfoo(self, foo=None): - self.foo = foo - def getfoo(self): - return self.__foo - def __getstate__(self): - return [self.foo] - def __setstate__(self, lst): - assert len(lst) == 1 - self.__foo = self.foo = lst[0] - a = C(42) - a.setfoo(24) - vereq(a.foo, 24) - vereq(a.getfoo(), 42) - b = copy.copy(a) - vereq(b.foo, 24) - vereq(b.getfoo(), 24) - b = copy.deepcopy(a) - vereq(b.foo, 24) - vereq(b.getfoo(), 24) - -def slices(): - if verbose: - print("Testing cases with slices and overridden __getitem__ ...") - # Strings - vereq("hello"[:4], "hell") - vereq("hello"[slice(4)], "hell") - vereq(str.__getitem__("hello", slice(4)), "hell") - class S(str): - def __getitem__(self, x): - return str.__getitem__(self, x) - vereq(S("hello")[:4], "hell") - vereq(S("hello")[slice(4)], "hell") - vereq(S("hello").__getitem__(slice(4)), "hell") - # Tuples - vereq((1,2,3)[:2], (1,2)) - vereq((1,2,3)[slice(2)], (1,2)) - vereq(tuple.__getitem__((1,2,3), slice(2)), (1,2)) - class T(tuple): - def __getitem__(self, x): - return tuple.__getitem__(self, x) - vereq(T((1,2,3))[:2], (1,2)) - vereq(T((1,2,3))[slice(2)], (1,2)) - vereq(T((1,2,3)).__getitem__(slice(2)), (1,2)) - # Lists - vereq([1,2,3][:2], [1,2]) - vereq([1,2,3][slice(2)], [1,2]) - vereq(list.__getitem__([1,2,3], slice(2)), [1,2]) - class L(list): - def __getitem__(self, x): - return list.__getitem__(self, x) - vereq(L([1,2,3])[:2], [1,2]) - vereq(L([1,2,3])[slice(2)], [1,2]) - vereq(L([1,2,3]).__getitem__(slice(2)), [1,2]) - # Now do lists and __setitem__ - a = L([1,2,3]) - a[slice(1, 3)] = [3,2] - vereq(a, [1,3,2]) - a[slice(0, 2, 1)] = [3,1] - vereq(a, [3,1,2]) - a.__setitem__(slice(1, 3), [2,1]) - vereq(a, [3,2,1]) - a.__setitem__(slice(0, 2, 1), [2,3]) - vereq(a, [2,3,1]) - -def subtype_resurrection(): - if verbose: - print("Testing resurrection of new-style instance...") - - class C(object): - container = [] - - def __del__(self): - # resurrect the instance - C.container.append(self) - - c = C() - c.attr = 42 - # The most interesting thing here is whether this blows up, due to flawed - # GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1 bug). - del c - - # If that didn't blow up, it's also interesting to see whether clearing - # the last container slot works: that will attempt to delete c again, - # which will cause c to get appended back to the container again "during" - # the del. - del C.container[-1] - vereq(len(C.container), 1) - vereq(C.container[-1].attr, 42) - - # Make c mortal again, so that the test framework with -l doesn't report - # it as a leak. - del C.__del__ - -def slottrash(): - # Deallocating deeply nested slotted trash caused stack overflows - if verbose: - print("Testing slot trash...") - class trash(object): - __slots__ = ['x'] - def __init__(self, x): - self.x = x - o = None - for i in range(50000): - o = trash(o) - del o - -def slotmultipleinheritance(): - # SF bug 575229, multiple inheritance w/ slots dumps core - class A(object): - __slots__=() - class B(object): - pass - class C(A,B) : - __slots__=() - vereq(C.__basicsize__, B.__basicsize__) - verify(hasattr(C, '__dict__')) - verify(hasattr(C, '__weakref__')) - C().x = 2 - -def testrmul(): - # SF patch 592646 - if verbose: - print("Testing correct invocation of __rmul__...") - class C(object): - def __mul__(self, other): - return "mul" - def __rmul__(self, other): - return "rmul" - a = C() - vereq(a*2, "mul") - vereq(a*2.2, "mul") - vereq(2*a, "rmul") - vereq(2.2*a, "rmul") - -def testipow(): - # [SF bug 620179] - if verbose: - print("Testing correct invocation of __ipow__...") - class C(object): - def __ipow__(self, other): + class E(D): pass - a = C() - a **= 2 + d = D() + e = E() + D.__bases__ = (C,) + D.__bases__ = (C2,) + self.assertEqual(d.meth(), 1) + self.assertEqual(e.meth(), 1) + self.assertEqual(d.a, 2) + self.assertEqual(e.a, 2) + self.assertEqual(C2.__subclasses__(), [D]) -def do_this_first(): - if verbose: - print("Testing SF bug 551412 ...") - # This dumps core when SF bug 551412 isn't fixed -- - # but only when test_descr.py is run separately. - # (That can't be helped -- as soon as PyType_Ready() - # is called for PyLong_Type, the bug is gone.) - class UserLong(object): - def __pow__(self, *args): + # stuff that shouldn't: + class L(list): pass - try: - pow(0, UserLong(), 0) - except: - pass - if verbose: - print("Testing SF bug 570483...") - # Another segfault only when run early - # (before PyType_Ready(tuple) is called) - type.mro(tuple) + try: + L.__bases__ = (dict,) + except TypeError: + pass + else: + self.fail("shouldn't turn list subclass into dict subclass") -def test_mutable_bases(): - if verbose: - print("Testing mutable bases...") - # stuff that should work: - class C(object): - pass - class C2(object): - def __getattribute__(self, attr): - if attr == 'a': - return 2 - else: - return super(C2, self).__getattribute__(attr) - def meth(self): - return 1 - class D(C): - pass - class E(D): - pass - d = D() - e = E() - D.__bases__ = (C,) - D.__bases__ = (C2,) - vereq(d.meth(), 1) - vereq(e.meth(), 1) - vereq(d.a, 2) - vereq(e.a, 2) - vereq(C2.__subclasses__(), [D]) + try: + list.__bases__ = (dict,) + except TypeError: + pass + else: + self.fail("shouldn't be able to assign to list.__bases__") - # stuff that shouldn't: - class L(list): - pass + try: + D.__bases__ = (C2, list) + except TypeError: + pass + else: + assert 0, "best_base calculation found wanting" - try: - L.__bases__ = (dict,) - except TypeError: - pass - else: - raise TestFailed("shouldn't turn list subclass into dict subclass") + try: + del D.__bases__ + except TypeError: + pass + else: + self.fail("shouldn't be able to delete .__bases__") - try: - list.__bases__ = (dict,) - except TypeError: - pass - else: - raise TestFailed("shouldn't be able to assign to list.__bases__") + try: + D.__bases__ = () + except TypeError as msg: + if str(msg) == "a new-style class can't have only classic bases": + self.fail("wrong error message for .__bases__ = ()") + else: + self.fail("shouldn't be able to set .__bases__ to ()") - try: - D.__bases__ = (C2, list) - except TypeError: - pass - else: - assert 0, "best_base calculation found wanting" + try: + D.__bases__ = (D,) + except TypeError: + pass + else: + # actually, we'll have crashed by here... + self.fail("shouldn't be able to create inheritance cycles") - try: - del D.__bases__ - except TypeError: - pass - else: - raise TestFailed("shouldn't be able to delete .__bases__") + try: + D.__bases__ = (C, C) + except TypeError: + pass + else: + self.fail("didn't detect repeated base classes") - try: - D.__bases__ = () - except TypeError as msg: - if str(msg) == "a new-style class can't have only classic bases": - raise TestFailed("wrong error message for .__bases__ = ()") - else: - raise TestFailed("shouldn't be able to set .__bases__ to ()") + try: + D.__bases__ = (E,) + except TypeError: + pass + else: + self.fail("shouldn't be able to create inheritance cycles") - try: - D.__bases__ = (D,) - except TypeError: - pass - else: - # actually, we'll have crashed by here... - raise TestFailed("shouldn't be able to create inheritance cycles") + def test_mutable_bases_with_failing_mro(self): + # Testing mutable bases with failing mro... + class WorkOnce(type): + def __new__(self, name, bases, ns): + self.flag = 0 + return super(WorkOnce, self).__new__(WorkOnce, name, bases, ns) + def mro(self): + if self.flag > 0: + raise RuntimeError("bozo") + else: + self.flag += 1 + return type.mro(self) - try: - D.__bases__ = (C, C) - except TypeError: - pass - else: - raise TestFailed("didn't detect repeated base classes") - - try: - D.__bases__ = (E,) - except TypeError: - pass - else: - raise TestFailed("shouldn't be able to create inheritance cycles") - -def test_mutable_bases_with_failing_mro(): - if verbose: - print("Testing mutable bases with failing mro...") - class WorkOnce(type): - def __new__(self, name, bases, ns): - self.flag = 0 - return super(WorkOnce, self).__new__(WorkOnce, name, bases, ns) - def mro(self): - if self.flag > 0: - raise RuntimeError("bozo") - else: - self.flag += 1 + class WorkAlways(type): + def mro(self): + # this is here to make sure that .mro()s aren't called + # with an exception set (which was possible at one point). + # An error message will be printed in a debug build. + # What's a good way to test for this? return type.mro(self) - class WorkAlways(type): - def mro(self): - # this is here to make sure that .mro()s aren't called - # with an exception set (which was possible at one point). - # An error message will be printed in a debug build. - # What's a good way to test for this? - return type.mro(self) + class C(object): + pass - class C(object): - pass + class C2(object): + pass - class C2(object): - pass + class D(C): + pass - class D(C): - pass + class E(D): + pass - class E(D): - pass + class F(D, metaclass=WorkOnce): + pass - class F(D, metaclass=WorkOnce): - pass + class G(D, metaclass=WorkAlways): + pass - class G(D, metaclass=WorkAlways): - pass + # Immediate subclasses have their mro's adjusted in alphabetical + # order, so E's will get adjusted before adjusting F's fails. We + # check here that E's gets restored. - # Immediate subclasses have their mro's adjusted in alphabetical - # order, so E's will get adjusted before adjusting F's fails. We - # check here that E's gets restored. + E_mro_before = E.__mro__ + D_mro_before = D.__mro__ - E_mro_before = E.__mro__ - D_mro_before = D.__mro__ - - try: - D.__bases__ = (C2,) - except RuntimeError: - vereq(E.__mro__, E_mro_before) - vereq(D.__mro__, D_mro_before) - else: - raise TestFailed("exception not propagated") - -def test_mutable_bases_catch_mro_conflict(): - if verbose: - print("Testing mutable bases catch mro conflict...") - class A(object): - pass - - class B(object): - pass - - class C(A, B): - pass - - class D(A, B): - pass - - class E(C, D): - pass - - try: - C.__bases__ = (B, A) - except TypeError: - pass - else: - raise TestFailed("didn't catch MRO conflict") - -def mutable_names(): - if verbose: - print("Testing mutable names...") - class C(object): - pass - - # C.__module__ could be 'test_descr' or '__main__' - mod = C.__module__ - - C.__name__ = 'D' - vereq((C.__module__, C.__name__), (mod, 'D')) - - C.__name__ = 'D.E' - vereq((C.__module__, C.__name__), (mod, 'D.E')) - -def subclass_right_op(): - if verbose: - print("Testing correct dispatch of subclass overloading __r__...") - - # This code tests various cases where right-dispatch of a subclass - # should be preferred over left-dispatch of a base class. - - # Case 1: subclass of int; this tests code in abstract.c::binary_op1() - - class B(int): - def __floordiv__(self, other): - return "B.__floordiv__" - def __rfloordiv__(self, other): - return "B.__rfloordiv__" - - vereq(B(1) // 1, "B.__floordiv__") - vereq(1 // B(1), "B.__rfloordiv__") - - # Case 2: subclass of object; this is just the baseline for case 3 - - class C(object): - def __floordiv__(self, other): - return "C.__floordiv__" - def __rfloordiv__(self, other): - return "C.__rfloordiv__" - - vereq(C() // 1, "C.__floordiv__") - vereq(1 // C(), "C.__rfloordiv__") - - # Case 3: subclass of new-style class; here it gets interesting - - class D(C): - def __floordiv__(self, other): - return "D.__floordiv__" - def __rfloordiv__(self, other): - return "D.__rfloordiv__" - - vereq(D() // C(), "D.__floordiv__") - vereq(C() // D(), "D.__rfloordiv__") - - # Case 4: this didn't work right in 2.2.2 and 2.3a1 - - class E(C): - pass - - vereq(E.__rfloordiv__, C.__rfloordiv__) - - vereq(E() // 1, "C.__floordiv__") - vereq(1 // E(), "C.__rfloordiv__") - vereq(E() // C(), "C.__floordiv__") - vereq(C() // E(), "C.__floordiv__") # This one would fail - -def dict_type_with_metaclass(): - if verbose: - print("Testing type of __dict__ when metaclass set...") - - class B(object): - pass - class M(type): - pass - class C(metaclass=M): - # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy - pass - veris(type(C.__dict__), type(B.__dict__)) - -def meth_class_get(): - # Full coverage of descrobject.c::classmethod_get() - if verbose: - print("Testing __get__ method of METH_CLASS C methods...") - # Baseline - arg = [1, 2, 3] - res = {1: None, 2: None, 3: None} - vereq(dict.fromkeys(arg), res) - vereq({}.fromkeys(arg), res) - # Now get the descriptor - descr = dict.__dict__["fromkeys"] - # More baseline using the descriptor directly - vereq(descr.__get__(None, dict)(arg), res) - vereq(descr.__get__({})(arg), res) - # Now check various error cases - try: - descr.__get__(None, None) - except TypeError: - pass - else: - raise TestFailed("shouldn't have allowed descr.__get__(None, None)") - try: - descr.__get__(42) - except TypeError: - pass - else: - raise TestFailed("shouldn't have allowed descr.__get__(42)") - try: - descr.__get__(None, 42) - except TypeError: - pass - else: - raise TestFailed("shouldn't have allowed descr.__get__(None, 42)") - try: - descr.__get__(None, int) - except TypeError: - pass - else: - raise TestFailed("shouldn't have allowed descr.__get__(None, int)") - -def isinst_isclass(): - if verbose: - print("Testing proxy isinstance() and isclass()...") - class Proxy(object): - def __init__(self, obj): - self.__obj = obj - def __getattribute__(self, name): - if name.startswith("_Proxy__"): - return object.__getattribute__(self, name) - else: - return getattr(self.__obj, name) - # Test with a classic class - class C: - pass - a = C() - pa = Proxy(a) - verify(isinstance(a, C)) # Baseline - verify(isinstance(pa, C)) # Test - # Test with a classic subclass - class D(C): - pass - a = D() - pa = Proxy(a) - verify(isinstance(a, C)) # Baseline - verify(isinstance(pa, C)) # Test - # Test with a new-style class - class C(object): - pass - a = C() - pa = Proxy(a) - verify(isinstance(a, C)) # Baseline - verify(isinstance(pa, C)) # Test - # Test with a new-style subclass - class D(C): - pass - a = D() - pa = Proxy(a) - verify(isinstance(a, C)) # Baseline - verify(isinstance(pa, C)) # Test - -def proxysuper(): - if verbose: - print("Testing super() for a proxy object...") - class Proxy(object): - def __init__(self, obj): - self.__obj = obj - def __getattribute__(self, name): - if name.startswith("_Proxy__"): - return object.__getattribute__(self, name) - else: - return getattr(self.__obj, name) - - class B(object): - def f(self): - return "B.f" - - class C(B): - def f(self): - return super(C, self).f() + "->C.f" - - obj = C() - p = Proxy(obj) - vereq(C.__dict__["f"](p), "B.f->C.f") - -def carloverre(): - if verbose: - print("Testing prohibition of Carlo Verre's hack...") - try: - object.__setattr__(str, "foo", 42) - except TypeError: - pass - else: - raise TestFailed("Carlo Verre __setattr__ suceeded!") - try: - object.__delattr__(str, "lower") - except TypeError: - pass - else: - raise TestFailed("Carlo Verre __delattr__ succeeded!") - -def weakref_segfault(): - # SF 742911 - if verbose: - print("Testing weakref segfault...") - - import weakref - - class Provoker: - def __init__(self, referrent): - self.ref = weakref.ref(referrent) - - def __del__(self): - x = self.ref() - - class Oops(object): - pass - - o = Oops() - o.whatever = Provoker(o) - del o - -def wrapper_segfault(): - # SF 927248: deeply nested wrappers could cause stack overflow - if verbose: - print("Testing wrapper segfault...") - f = lambda:None - for i in range(1000000): - f = f.__call__ - f = None - -# Fix SF #762455, segfault when sys.stdout is changed in getattr -def filefault(): - if verbose: - print("Testing sys.stdout is changed in getattr...") - import sys - class StdoutGuard: - def __getattr__(self, attr): - sys.stdout = sys.__stdout__ - raise RuntimeError("Premature access to sys.stdout.%s" % attr) - sys.stdout = StdoutGuard() - try: - print("Oops!") - except RuntimeError: - pass - -def vicious_descriptor_nonsense(): - # A potential segfault spotted by Thomas Wouters in mail to - # python-dev 2003-04-17, turned into an example & fixed by Michael - # Hudson just less than four months later... - if verbose: - print("Testing vicious_descriptor_nonsense...") - - class Evil(object): - def __hash__(self): - return hash('attr') - def __eq__(self, other): - del C.attr - return 0 - - class Descr(object): - def __get__(self, ob, type=None): - return 1 - - class C(object): - attr = Descr() - - c = C() - c.__dict__[Evil()] = 0 - - vereq(c.attr, 1) - # this makes a crash more likely: - import gc; gc.collect() - vereq(hasattr(c, 'attr'), False) - -def test_init(): - # SF 1155938 - class Foo(object): - def __init__(self): - return 10 - try: - Foo() - except TypeError: - pass - else: - raise TestFailed("did not test __init__() for None return") - -def methodwrapper(): - # did not support any reflection before 2.5 - if verbose: - print("Testing method-wrapper objects...") - - return # XXX should methods really support __eq__? - - l = [] - vereq(l.__add__, l.__add__) - vereq(l.__add__, [].__add__) - verify(l.__add__ != [5].__add__) - verify(l.__add__ != l.__mul__) - verify(l.__add__.__name__ == '__add__') - verify(l.__add__.__self__ is l) - verify(l.__add__.__objclass__ is list) - vereq(l.__add__.__doc__, list.__add__.__doc__) - try: - hash(l.__add__) - except TypeError: - pass - else: - raise TestFailed("no TypeError from hash([].__add__)") - - t = () - t += (7,) - vereq(t.__add__, (7,).__add__) - vereq(hash(t.__add__), hash((7,).__add__)) - -def notimplemented(): - # all binary methods should be able to return a NotImplemented - if verbose: - print("Testing NotImplemented...") - - import sys - import types - import operator - - def specialmethod(self, other): - return NotImplemented - - def check(expr, x, y): try: - exec(expr, {'x': x, 'y': y, 'operator': operator}) + D.__bases__ = (C2,) + except RuntimeError: + self.assertEqual(E.__mro__, E_mro_before) + self.assertEqual(D.__mro__, D_mro_before) + else: + self.fail("exception not propagated") + + def test_mutable_bases_catch_mro_conflict(self): + # Testing mutable bases catch mro conflict... + class A(object): + pass + + class B(object): + pass + + class C(A, B): + pass + + class D(A, B): + pass + + class E(C, D): + pass + + try: + C.__bases__ = (B, A) except TypeError: pass else: - raise TestFailed("no TypeError from %r" % (expr,)) + self.fail("didn't catch MRO conflict") - N1 = sys.maxsize + 1 # might trigger OverflowErrors instead of TypeErrors - N2 = sys.maxsize # if sizeof(int) < sizeof(long), might trigger - # ValueErrors instead of TypeErrors - if 1: - metaclass = type + def test_mutable_names(self): + # Testing mutable names... + class C(object): + pass + + # C.__module__ could be 'test_descr' or '__main__' + mod = C.__module__ + + C.__name__ = 'D' + self.assertEqual((C.__module__, C.__name__), (mod, 'D')) + + C.__name__ = 'D.E' + self.assertEqual((C.__module__, C.__name__), (mod, 'D.E')) + + def test_subclass_right_op(self): + # Testing correct dispatch of subclass overloading __r__... + + # This code tests various cases where right-dispatch of a subclass + # should be preferred over left-dispatch of a base class. + + # Case 1: subclass of int; this tests code in abstract.c::binary_op1() + + class B(int): + def __floordiv__(self, other): + return "B.__floordiv__" + def __rfloordiv__(self, other): + return "B.__rfloordiv__" + + self.assertEqual(B(1) // 1, "B.__floordiv__") + self.assertEqual(1 // B(1), "B.__rfloordiv__") + + # Case 2: subclass of object; this is just the baseline for case 3 + + class C(object): + def __floordiv__(self, other): + return "C.__floordiv__" + def __rfloordiv__(self, other): + return "C.__rfloordiv__" + + self.assertEqual(C() // 1, "C.__floordiv__") + self.assertEqual(1 // C(), "C.__rfloordiv__") + + # Case 3: subclass of new-style class; here it gets interesting + + class D(C): + def __floordiv__(self, other): + return "D.__floordiv__" + def __rfloordiv__(self, other): + return "D.__rfloordiv__" + + self.assertEqual(D() // C(), "D.__floordiv__") + self.assertEqual(C() // D(), "D.__rfloordiv__") + + # Case 4: this didn't work right in 2.2.2 and 2.3a1 + + class E(C): + pass + + self.assertEqual(E.__rfloordiv__, C.__rfloordiv__) + + self.assertEqual(E() // 1, "C.__floordiv__") + self.assertEqual(1 // E(), "C.__rfloordiv__") + self.assertEqual(E() // C(), "C.__floordiv__") + self.assertEqual(C() // E(), "C.__floordiv__") # This one would fail + + def test_meth_class_get(self): + # Testing __get__ method of METH_CLASS C methods... + # Full coverage of descrobject.c::classmethod_get() + + # Baseline + arg = [1, 2, 3] + res = {1: None, 2: None, 3: None} + self.assertEqual(dict.fromkeys(arg), res) + self.assertEqual({}.fromkeys(arg), res) + + # Now get the descriptor + descr = dict.__dict__["fromkeys"] + + # More baseline using the descriptor directly + self.assertEqual(descr.__get__(None, dict)(arg), res) + self.assertEqual(descr.__get__({})(arg), res) + + # Now check various error cases + try: + descr.__get__(None, None) + except TypeError: + pass + else: + self.fail("shouldn't have allowed descr.__get__(None, None)") + try: + descr.__get__(42) + except TypeError: + pass + else: + self.fail("shouldn't have allowed descr.__get__(42)") + try: + descr.__get__(None, 42) + except TypeError: + pass + else: + self.fail("shouldn't have allowed descr.__get__(None, 42)") + try: + descr.__get__(None, int) + except TypeError: + pass + else: + self.fail("shouldn't have allowed descr.__get__(None, int)") + + def test_isinst_isclass(self): + # Testing proxy isinstance() and isclass()... + class Proxy(object): + def __init__(self, obj): + self.__obj = obj + def __getattribute__(self, name): + if name.startswith("_Proxy__"): + return object.__getattribute__(self, name) + else: + return getattr(self.__obj, name) + # Test with a classic class + class C: + pass + a = C() + pa = Proxy(a) + self.assert_(isinstance(a, C)) # Baseline + self.assert_(isinstance(pa, C)) # Test + # Test with a classic subclass + class D(C): + pass + a = D() + pa = Proxy(a) + self.assert_(isinstance(a, C)) # Baseline + self.assert_(isinstance(pa, C)) # Test + # Test with a new-style class + class C(object): + pass + a = C() + pa = Proxy(a) + self.assert_(isinstance(a, C)) # Baseline + self.assert_(isinstance(pa, C)) # Test + # Test with a new-style subclass + class D(C): + pass + a = D() + pa = Proxy(a) + self.assert_(isinstance(a, C)) # Baseline + self.assert_(isinstance(pa, C)) # Test + + def test_proxy_super(self): + # Testing super() for a proxy object... + class Proxy(object): + def __init__(self, obj): + self.__obj = obj + def __getattribute__(self, name): + if name.startswith("_Proxy__"): + return object.__getattribute__(self, name) + else: + return getattr(self.__obj, name) + + class B(object): + def f(self): + return "B.f" + + class C(B): + def f(self): + return super(C, self).f() + "->C.f" + + obj = C() + p = Proxy(obj) + self.assertEqual(C.__dict__["f"](p), "B.f->C.f") + + def test_carloverre(self): + # Testing prohibition of Carlo Verre's hack... + try: + object.__setattr__(str, "foo", 42) + except TypeError: + pass + else: + self.fail("Carlo Verre __setattr__ suceeded!") + try: + object.__delattr__(str, "lower") + except TypeError: + pass + else: + self.fail("Carlo Verre __delattr__ succeeded!") + + def test_weakref_segfault(self): + # Testing weakref segfault... + # SF 742911 + import weakref + + class Provoker: + def __init__(self, referrent): + self.ref = weakref.ref(referrent) + + def __del__(self): + x = self.ref() + + class Oops(object): + pass + + o = Oops() + o.whatever = Provoker(o) + del o + + def test_wrapper_segfault(self): + # SF 927248: deeply nested wrappers could cause stack overflow + f = lambda:None + for i in range(1000000): + f = f.__call__ + f = None + + def test_file_fault(self): + # Testing sys.stdout is changed in getattr... + import sys + class StdoutGuard: + def __getattr__(self, attr): + sys.stdout = sys.__stdout__ + raise RuntimeError("Premature access to sys.stdout.%s" % attr) + sys.stdout = StdoutGuard() + try: + print("Oops!") + except RuntimeError: + pass + + def test_vicious_descriptor_nonsense(self): + # Testing vicious_descriptor_nonsense... + + # A potential segfault spotted by Thomas Wouters in mail to + # python-dev 2003-04-17, turned into an example & fixed by Michael + # Hudson just less than four months later... + + class Evil(object): + def __hash__(self): + return hash('attr') + def __eq__(self, other): + del C.attr + return 0 + + class Descr(object): + def __get__(self, ob, type=None): + return 1 + + class C(object): + attr = Descr() + + c = C() + c.__dict__[Evil()] = 0 + + self.assertEqual(c.attr, 1) + # this makes a crash more likely: + import gc; gc.collect() + self.assertEqual(hasattr(c, 'attr'), False) + + def test_init(self): + # SF 1155938 + class Foo(object): + def __init__(self): + return 10 + try: + Foo() + except TypeError: + pass + else: + self.fail("did not test __init__() for None return") + + def test_method_wrapper(self): + # Testing method-wrapper objects... + # did not support any reflection before 2.5 + + return # XXX should methods really support __eq__? + + l = [] + self.assertEqual(l.__add__, l.__add__) + self.assertEqual(l.__add__, [].__add__) + self.assert_(l.__add__ != [5].__add__) + self.assert_(l.__add__ != l.__mul__) + self.assert_(l.__add__.__name__ == '__add__') + self.assert_(l.__add__.__self__ is l) + self.assert_(l.__add__.__objclass__ is list) + self.assertEqual(l.__add__.__doc__, list.__add__.__doc__) + try: + hash(l.__add__) + except TypeError: + pass + else: + self.fail("no TypeError from hash([].__add__)") + + t = () + t += (7,) + self.assertEqual(t.__add__, (7,).__add__) + self.assertEqual(hash(t.__add__), hash((7,).__add__)) + + def test_not_implemented(self): + # Testing NotImplemented... + # all binary methods should be able to return a NotImplemented + import sys + import types + import operator + + def specialmethod(self, other): + return NotImplemented + + def check(expr, x, y): + try: + exec(expr, {'x': x, 'y': y, 'operator': operator}) + except TypeError: + pass + else: + self.fail("no TypeError from %r" % (expr,)) + + N1 = sys.maxsize + 1 # might trigger OverflowErrors instead of + # TypeErrors + N2 = sys.maxsize # if sizeof(int) < sizeof(long), might trigger + # ValueErrors instead of TypeErrors for name, expr, iexpr in [ ('__add__', 'x + y', 'x += y'), ('__sub__', 'x - y', 'x -= y'), ('__mul__', 'x * y', 'x *= y'), - ('__truediv__', 'x / y', None), - ('__floordiv__', 'x // y', None), + ('__truediv__', 'operator.truediv(x, y)', None), + ('__floordiv__', 'operator.floordiv(x, y)', None), + ('__div__', 'x / y', 'x /= y'), ('__mod__', 'x % y', 'x %= y'), ('__divmod__', 'divmod(x, y)', None), ('__pow__', 'x ** y', 'x **= y'), @@ -4139,241 +3982,102 @@ def notimplemented(): ('__rshift__', 'x >> y', 'x >>= y'), ('__and__', 'x & y', 'x &= y'), ('__or__', 'x | y', 'x |= y'), - ('__xor__', 'x ^ y', 'x ^= y'), - ]: + ('__xor__', 'x ^ y', 'x ^= y')]: rname = '__r' + name[2:] - A = metaclass('A', (), {name: specialmethod}) - B = metaclass('B', (), {rname: specialmethod}) + A = type('A', (), {name: specialmethod}) a = A() - b = B() check(expr, a, a) - check(expr, a, b) - check(expr, b, a) - check(expr, b, b) check(expr, a, N1) check(expr, a, N2) - check(expr, N1, b) - check(expr, N2, b) if iexpr: check(iexpr, a, a) - check(iexpr, a, b) - check(iexpr, b, a) - check(iexpr, b, b) check(iexpr, a, N1) check(iexpr, a, N2) iname = '__i' + name[2:] - C = metaclass('C', (), {iname: specialmethod}) + C = type('C', (), {iname: specialmethod}) c = C() check(iexpr, c, a) - check(iexpr, c, b) check(iexpr, c, N1) check(iexpr, c, N2) -def test_assign_slice(): - # ceval.c's assign_slice used to check for - # tp->tp_as_sequence->sq_slice instead of - # tp->tp_as_sequence->sq_ass_slice - if verbose: - print("Testing assign_slice...") + def test_assign_slice(self): + # ceval.c's assign_slice used to check for + # tp->tp_as_sequence->sq_slice instead of + # tp->tp_as_sequence->sq_ass_slice - class C(object): - def __setitem__(self, idx, value): - self.value = value + class C(object): + def __setitem__(self, idx, value): + self.value = value - c = C() - c[1:2] = 3 - vereq(c.value, 3) + c = C() + c[1:2] = 3 + self.assertEqual(c.value, 3) -def test_weakref_in_del_segfault(): - # This used to segfault until r60057 - if verbose: - print("Testing weakref in del segfault...") - import weakref - global ref +class DictProxyTests(unittest.TestCase): + def setUp(self): + class C(object): + def meth(self): + pass + self.C = C - class Target(): - def __del__(self): - global ref - ref = weakref.ref(self) + def test_iter_keys(self): + # Testing dict-proxy iterkeys... + keys = [ key for key in self.C.__dict__.keys() ] + keys.sort() + self.assertEquals(keys, ['__dict__', '__doc__', '__module__', + '__weakref__', 'meth']) - w = Target() - del w - del ref + def test_iter_values(self): + # Testing dict-proxy itervalues... + values = [ values for values in self.C.__dict__.values() ] + self.assertEqual(len(values), 5) -def test_borrowed_ref_3_segfault(): - # This used to segfault until r60224 - if verbose: - print("Testing borrowed ref 3 segfault...") + def test_iter_items(self): + # Testing dict-proxy iteritems... + keys = [ key for (key, value) in self.C.__dict__.items() ] + keys.sort() + self.assertEqual(keys, ['__dict__', '__doc__', '__module__', + '__weakref__', 'meth']) - class KeyFunc(object): - def __call__(self, n): - del d['key'] - return 1 + def test_dict_type_with_metaclass(self): + # Testing type of __dict__ when metaclass set... + class B(object): + pass + class M(type): + pass + class C(metaclass=M): + # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy + pass + self.assertEqual(type(C.__dict__), type(B.__dict__)) - d = {'key': KeyFunc()} - try: - min(range(10), **d) - except: - pass -def test_borrowed_ref_4_segfault(): - # This used to segfault until r60224 - if verbose: - print("Testing borrowed ref 4 segfault...") +class PTypesLongInitTest(unittest.TestCase): + # This is in its own TestCase so that it can be run before any other tests. + def test_pytype_long_ready(self): + # Testing SF bug 551412 ... - import types - import builtins + # This dumps core when SF bug 551412 isn't fixed -- + # but only when test_descr.py is run separately. + # (That can't be helped -- as soon as PyType_Ready() + # is called for PyLong_Type, the bug is gone.) + class UserLong(object): + def __pow__(self, *args): + pass + try: + pow(0, UserLong(), 0) + except: + pass - class X(object): - def __getattr__(self, name): - # this is called with name == '__bases__' by PyObject_IsInstance() - # during the unbound method call -- it frees the unbound method - # itself before it invokes its im_func. - del builtins.__import__ - return () - - pseudoclass = X() - - class Y(object): - def __call__(self, *args): - # 'self' was freed already - return (self, args) - - # make an unbound method - orig_import = __import__ - try: - builtins.__import__ = types.MethodType(Y(), (pseudoclass, str)) - import spam - finally: - builtins.__import__ = orig_import - -def test_losing_dict_ref_segfault(): - # This used to segfault; - # derived from issue #1303614, test67.py - if verbose: - print("Testing losing dict ref segfault...") - - class Strange(object): - def __hash__(self): - return hash('hello') - - def __eq__(self, other): - x.__dict__ = {} # the old x.__dict__ is deallocated - return False - - class X(object): - pass - - v = 123 - x = X() - x.__dict__ = {Strange(): 42, 'hello': v+456} - x.hello + # Another segfault only when run early + # (before PyType_Ready(tuple) is called) + type.mro(tuple) def test_main(): - weakref_segfault() # Must be first, somehow - wrapper_segfault() # NB This one is slow - do_this_first() - class_docstrings() - lists() - dicts() - dict_constructor() - test_dir() - ints() - longs() - floats() - complexes() - spamlists() - spamdicts() - pydicts() - pylists() - metaclass() - pymods() - multi() - mro_disagreement() - diamond() - ex5() - monotonicity() - consistency_with_epg() - objects() - slots() - slotspecials() - dynamics() - errors() - classmethods() - classmethods_in_c() - staticmethods() - staticmethods_in_c() - classic() - compattr() - newslot() - altmro() - overloading() - methods() - specials() - recursions() - weakrefs() - properties() - properties_plus() - supers() - inherits() - keywords() - str_subclass_as_dict_key() - classic_comparisons() - rich_comparisons() - descrdoc() - setclass() - setdict() - pickles() - copies() - binopoverride() - subclasspropagation() - buffer_inherit() - str_of_str_subclass() - kwdargs() - recursive__call__() - delhook() - hashinherit() - strops() - deepcopyrecursive() - modules() - dictproxyiterkeys() - dictproxyitervalues() - dictproxyiteritems() - pickleslots() - funnynew() - imulbug() - docdescriptor() - copy_setstate() - slices() - subtype_resurrection() - slottrash() - slotmultipleinheritance() - testrmul() - testipow() - test_mutable_bases() - test_mutable_bases_with_failing_mro() - test_mutable_bases_catch_mro_conflict() - mutable_names() - subclass_right_op() - dict_type_with_metaclass() - meth_class_get() - isinst_isclass() - proxysuper() - carloverre() - filefault() - vicious_descriptor_nonsense() - test_init() - methodwrapper() - notimplemented() - test_assign_slice() - test_weakref_in_del_segfault() - test_borrowed_ref_3_segfault() - test_borrowed_ref_4_segfault() - test_losing_dict_ref_segfault() - - if verbose: print("All OK") + # Run all local test cases, with PTypesLongInitTest first. + test_support.run_unittest(PTypesLongInitTest, OperatorsTest, + ClassPropertiesAndMethods, DictProxyTests) if __name__ == "__main__": test_main()