/lib-python/modified-2.7/test/test_descr.py
Python | 4677 lines | 4230 code | 269 blank | 178 comment | 272 complexity | 9cee9a9d8dd24ef7f42c0e2ea08755ca MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- import __builtin__
- import sys
- import types
- import unittest
- import popen2 # trigger early the warning from popen2.py
- from copy import deepcopy
- from test import test_support
- class OperatorsTest(unittest.TestCase):
- 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': '>=',
- }
- for name, expr in self.binops.items():
- if expr.islower():
- expr = expr + "(a, b)"
- else:
- expr = 'a %s b' % expr
- self.binops[name] = expr
- self.unops = {
- 'pos': '+',
- 'neg': '-',
- 'abs': 'abs',
- 'invert': '~',
- 'int': 'int',
- 'long': 'long',
- 'float': 'float',
- 'oct': 'oct',
- 'hex': 'hex',
- }
- for name, expr in self.unops.items():
- if expr.islower():
- expr = expr + "(a)"
- else:
- expr = '%s a' % expr
- self.unops[name] = expr
- 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)
- # Find method in parent class
- while meth not in t.__dict__:
- t = t.__bases__[0]
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound
- # method object; the getattr() below obtains its underlying function.
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])
- self.assertEqual(m(a), res)
- bm = getattr(a, meth)
- self.assertEqual(bm(), res)
- def binop_test(self, a, b, res, expr="a+b", meth="__add__"):
- d = {'a': a, 'b': b}
- # XXX Hack so this passes before 2.3 when -Qnew is specified.
- if meth == "__div__" and 1/2 == 0.5:
- meth = "__truediv__"
- if meth == '__divmod__': pass
- self.assertEqual(eval(expr, d), res)
- t = type(a)
- m = getattr(t, meth)
- while meth not in t.__dict__:
- t = t.__bases__[0]
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound
- # method object; the getattr() below obtains its underlying function.
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])
- self.assertEqual(m(a, b), res)
- bm = getattr(a, meth)
- self.assertEqual(bm(b), res)
- def ternop_test(self, a, b, c, res, expr="a[b:c]", meth="__getslice__"):
- 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]
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound
- # method object; the getattr() below obtains its underlying function.
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])
- self.assertEqual(m(a, b, c), res)
- bm = getattr(a, meth)
- self.assertEqual(bm(b, c), res)
- def setop_test(self, a, b, res, stmt="a+=b", meth="__iadd__"):
- d = {'a': deepcopy(a), 'b': b}
- exec stmt in d
- self.assertEqual(d['a'], res)
- t = type(a)
- m = getattr(t, meth)
- while meth not in t.__dict__:
- t = t.__bases__[0]
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound
- # method object; the getattr() below obtains its underlying function.
- self.assertEqual(getattr(m, 'im_func', 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 set2op_test(self, a, b, c, res, stmt="a[b]=c", meth="__setitem__"):
- d = {'a': deepcopy(a), 'b': b, 'c': c}
- exec stmt in d
- self.assertEqual(d['a'], res)
- t = type(a)
- m = getattr(t, meth)
- while meth not in t.__dict__:
- t = t.__bases__[0]
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound
- # method object; the getattr() below obtains its underlying function.
- self.assertEqual(getattr(m, 'im_func', 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 set3op_test(self, a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"):
- dictionary = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}
- exec stmt in dictionary
- self.assertEqual(dictionary['a'], res)
- t = type(a)
- while meth not in t.__dict__:
- t = t.__bases__[0]
- m = getattr(t, meth)
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound
- # method object; the getattr() below obtains its underlying function.
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])
- dictionary['a'] = deepcopy(a)
- m(dictionary['a'], b, c, d)
- self.assertEqual(dictionary['a'], res)
- dictionary['a'] = deepcopy(a)
- bm = getattr(dictionary['a'], meth)
- bm(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.ternop_test([1,2,3], 0, 2, [1,2], "a[b:c]", "__getslice__")
- 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.set3op_test([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d",
- "__setslice__")
- def test_dicts(self):
- # Testing dict operations...
- if hasattr(dict, '__cmp__'): # PyPy has only rich comparison on dicts
- self.binop_test({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__")
- else:
- self.binop_test({1:2}, {2:1}, True, "a < b", "__lt__")
- 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 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 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 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).__nonzero__(), 1)
- self.assertEqual((0).__nonzero__(), 0)
- # This returns 'NotImplemented' in Python 2.2
- class C(int):
- def __add__(self, other):
- return NotImplemented
- self.assertEqual(C(5L), 5)
- try:
- C() + ""
- except TypeError:
- pass
- else:
- self.fail("NotImplemented should have caused TypeError")
- try:
- C(sys.maxint+1)
- except OverflowError:
- pass
- else:
- self.fail("should have raised OverflowError")
- def test_longs(self):
- # Testing long operations...
- self.number_operators(100L, 3L)
- def test_floats(self):
- # Testing float operations...
- self.number_operators(100.0, 3.0)
- def test_complexes(self):
- # Testing complex operations...
- self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',
- 'int', 'long', 'float'])
- 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)
- self.assertEqual(repr(a), "3.14")
- self.assertEqual(a.prec, 6)
- a = Number(a, prec=2)
- self.assertEqual(repr(a), "3.1")
- self.assertEqual(a.prec, 2)
- a = Number(234.5)
- self.assertEqual(repr(a), "234.5")
- self.assertEqual(a.prec, 12)
- @test_support.impl_detail("the module 'xxsubtype' is internal")
- 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.ternop_test(spamlist([1,2,3]), 0, 2, spamlist([1,2]), "a[b:c]",
- "__getslice__")
- 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.set3op_test(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),
- spamlist([1,5,6,4]), "a[b:c]=d", "__setslice__")
- # 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)
- @test_support.impl_detail("the module 'xxsubtype' is internal")
- 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 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 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(a.items(), [])
- self.assertEqual(a.foo(), 1)
- a['foo'] = 'bar'
- self.assertEqual(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.assertTrue(issubclass(dict, dict))
- self.assertIsInstance({}, dict)
- d = dict()
- self.assertEqual(d, {})
- self.assertTrue(d.__class__ is dict)
- self.assertIsInstance(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 kw.items():
- self_local[v] = k
- def __getitem__(self, key):
- return self.get(key, 0)
- def __setitem__(self_local, key, value):
- self.assertIsInstance(key, type(0))
- dict.__setitem__(self_local, key, value)
- def setstate(self, state):
- self.state = state
- def getstate(self):
- return self.state
- self.assertTrue(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):
- return list.__getitem__(self, i) + 100
- def __getslice__(self, i, j):
- return (i, j)
- 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 D:
- class __metaclass__(type):
- def myself(cls): return cls
- 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
- 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.assertIn('spam', 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.iteritems():
- 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.iteritems():
- 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.assertTrue(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
- 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
- # 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 = []
- 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:
- class Module(types.ModuleType, str):
- pass
- except TypeError:
- pass
- else:
- self.fail("inheriting from ModuleType and str at the same time "
- "should fail")
- def test_multiple_inheritence(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(d.keys(), [])
- d["hello"] = "world"
- self.assertEqual(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))
- # 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)
- # MI mixing classic and new-style classes.
- class A:
- x = 1
- class B(A):
- pass
- class C(A):
- x = 2
- class D(B, C):
- pass
- self.assertEqual(D.x, 1)
- # Classic MRO is preserved for a classic base class.
- class E(D, object):
- pass
- self.assertEqual(E.__mro__, (E, D, B, A, C, object))
- self.assertEqual(E.x, 1)
- # But with a mix of classic bases, their MROs are combined using
- # new-style MRO.
- class F(B, C, object):
- pass
- self.assertEqual(F.__mro__, (F, B, C, A, object))
- self.assertEqual(F.x, 2)
- # Try something else.
- class C:
- def cmethod(self):
- return "C a"
- def all_method(self):
- return "C b"
- class M1(C, object):
- def m1method(self):
- return "M1 a"
- def all_method(self):
- return "M1 b"
- self.assertEqual(M1.__mro__, (M1, C, object))
- m = M1()
- self.assertEqual(m.cmethod(), "C a")
- self.assertEqual(m.m1method(), "M1 a")
- self.assertEqual(m.all_method(), "M1 b")
- class D(C):
- def dmethod(self):
- return "D a"
- def all_method(self):
- return "D b"
- class M2(D, object):
- def m2method(self):
- return "M2 a"
- def all_method(self):
- return "M2 b"
- self.assertEqual(M2.__mro__, (M2, D, C, object))
- m = M2()
- self.assertEqual(m.cmethod(), "C a")
- self.assertEqual(m.dmethod(), "D a")
- self.assertEqual(m.m2method(), "M2 a")
- self.assertEqual(m.all_method(), "M2 b")
- class M3(M1, M2, object):
- def m3method(self):
- return "M3 a"
- def all_method(self):
- return "M3 b"
- self.assertEqual(M3.__mro__, (M3, M1, M2, D, C, object))
- m = M3()
- self.assertEqual(m.cmethod(), "C a")
- self.assertEqual(m.dmethod(), "D a")
- self.assertEqual(m.m1method(), "M1 a")
- self.assertEqual(m.m2method(), "M2 a")
- self.assertEqual(m.m3method(), "M3 a")
- self.assertEqual(m.all_method(), "M3 b")
- class Classic:
- pass
- try:
- class New(Classic):
- __metaclass__ = type
- except TypeError:
- pass
- else:
- self.fail("new class with only classic bases - shouldn't be")
- 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
- 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)")
- # 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))
- # 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
- 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 consistency 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
- self.assertEqual(EditableScrollablePane.__mro__,
- (EditableScrollablePane, ScrollablePane, EditablePane, Pane,
- ScrollingMixin, EditingMixin, object))
- 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 raises(exc, expected, callable, *args):
- try:
- callable(*args)
- except exc, msg:
- # the exact msg is generally considered an impl detail
- if test_support.check_impl_detail():
- if not str(msg).startswith(expected):
- self.fail("Message %r, expected %r" %
- (str(msg), expected))
- else:
- self.fail("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 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:
- a.foo = 12
- except (AttributeError, TypeError):
- pass
- else:
- self.fail("object() should not allow setting a foo attribute")
- self.assertFalse(hasattr(object(), "__dict__"))
- class Cdict(object):
- pass
- x = Cdict()
- self.assertEqual(x.__dict__, {})
- x.foo = 1
- self.assertEqual(x.foo, 1)
- self.assertEqual(x.__dict__, {'foo': 1})
- 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
- self.assertEqual(x.a, 1)
- x.a = None
- self.assertEqual(x.a, None)
- del x.a
- self.assertFalse(hasattr(x, "a"))
- 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.__a = 6
- except AttributeError:
- pass
- else:
- self.fail("Double underscored names not mangled")
- # Make sure slot names are proper identifiers
- try:
- class C(object):
- __slots__ = [None]
- except TypeError:
- pass
- else:
- self.fail("[None] slots not caught")
- try:
- class C(object):
- __slots__ = ["foo bar"]
- except TypeError:
- pass
- else:
- 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)
- # Test unicode slot names
- try:
- unicode
- except NameError:
- pass
- else:
- # Test a single unicode string is not expanded as a sequence.
- class C(object):
- __slots__ = unicode("abc")
- c = C()
- c.abc = 5
- self.assertEqual(c.abc, 5)
- # _unicode_to_string used to modify slots in certain circumstances
- slots = (unicode("foo"), unicode("bar"))
- class C(object):
- __slots__ = slots
- x = C()
- x.foo = 5
- self.assertEqual(x.foo, 5)
- self.assertEqual(type(slots[0]), unicode)
- # this used to leak references
- try:
- class C(object):
- __slots__ = [unichr(128)]
- except (TypeError, UnicodeEncodeError):
- pass
- else:
- self.fail("[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()
- self.assertEqual(Counted.counter, 3)
- del x
- test_support.gc_collect()
- self.assertEqual(Counted.counter, 0)
- class D(C):
- pass
- x = D()
- x.a = Counted()
- x.z = Counted()
- self.assertEqual(Counted.counter, 2)
- del x
- test_support.gc_collect()
- 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
- test_support.gc_collect()
- self.assertEqual(Counted.counter, 0)
- # Test cyclical leaks [SF bug 519621]
- class F(object):
- __slots__ = ['a', 'b']
- s = F()
- s.a = [Counted(), s]
- self.assertEqual(Counted.counter, 1)
- s = None
- test_support.gc_collect()
- self.assertEqual(Counted.counter, 0)
- # Test lookup leaks [SF bug 572567]
- import gc
- if test_support.check_impl_detail():
- class G(object):
- def __cmp__(self, other):
- return 0
- __hash__ = None # Silence Py3k warning
- g = G()
- orig_objects = len(gc.get_objects())
- for i in xrange(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)
- with test_support.captured_output('stderr') as s:
- h = H()
- del h
- self.assertEqual(s.getvalue(), '')
- class X(object):
- __slots__ = "a"
- with self.assertRaises(AttributeError):
- del X().a
- def test_slots_special(self):
- # Testing __dict__ and __weakref__ in __slots__...
- class D(object):
- __slots__ = ["__dict__"]
- a = D()
- self.assertTrue(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.assertTrue(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.assertTrue(hasattr(a, "__dict__"))
- self.assertTrue(hasattr(a, "__weakref__"))
- a.foo = 42
- self.assertEqual(a.__dict__, {"foo": 42})
- class C2(D, W):
- __slots__ = []
- a = C2()
- self.assertTrue(hasattr(a, "__dict__"))
- self.assertTrue(hasattr(a, "__weakref__"))
- a.foo = 42
- self.assertEqual(a.__dict__, {"foo": 42})
- def test_slots_descriptor(self):
- # Issue2115: slot descriptors did not correctly check
- # the type of the given object
- import abc
- class MyABC:
- __metaclass__ = abc.ABCMeta
- __slots__ = "a"
- class Unrelated(object):
- pass
- MyABC.register(Unrelated)
- u = Unrelated()
- self.assertIsInstance(u, MyABC)
- # This used to crash
- self.assertRaises(TypeError, MyABC.a.__set__, u, 3)
- def test_metaclass_cmp(self):
- # See bug 7491.
- class M(type):
- def __cmp__(self, other):
- return -1
- class X(object):
- __metaclass__ = M
- self.assertTrue(X < M)
- 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(long):
- pass
- self.assertEqual("a"*L(2L), "aa")
- self.assertEqual(L(2L)*"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
- 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
- class A2(object):
- __metaclass__ = M2
- 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.im_self, C)
- self.assertEqual(D.goo.im_self, D)
- self.assertEqual(super(D,D).goo.im_self, D)
- self.assertEqual(super(D,d).goo.im_self, D)
- self.assertEqual(super(D,D).goo(), (D,))
- self.assertEqual(super(D,d).goo(), (D,))
- # Verify that a non-callable will raise
- meth = classmethod(1).__get__(1)
- self.assertRaises(TypeError, meth)
- # 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")
- @test_support.impl_detail("the module 'xxsubtype' is internal")
- 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))
- @test_support.impl_detail("the module 'xxsubtype' is internal")
- 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, C.foo) # i.e., unbound
- self.assertTrue(repr(C.foo.__get__(C())).startswith("<bound method "))
- def test_compattr(self):
- # Testing computed attributes...
- class C(object):
- class computed_attribute(object):
- def __init__(self, get, set=None, delete=None):
- self.__get = get
- self.__set = set
- self.__delete = delete
- def __get__(self, obj, type=None):
- return self.__get(obj)
- def __set__(self, obj, value):
- return self.__set(obj, value)
- def __delete__(self, obj):
- return self.__delete(obj)
- def __init__(self):
- self.__x = 0
- def __get_x(self):
- x = self.__x
- self.__x = x+1
- return x
- def __set_x…
Large files files are truncated, but you can click here to view the full file