+++ /dev/null
-import __builtin__\r
-import sys\r
-import types\r
-import unittest\r
-\r
-from copy import deepcopy\r
-from test import test_support\r
-\r
-\r
-class OperatorsTest(unittest.TestCase):\r
-\r
- def __init__(self, *args, **kwargs):\r
- unittest.TestCase.__init__(self, *args, **kwargs)\r
- self.binops = {\r
- 'add': '+',\r
- 'sub': '-',\r
- 'mul': '*',\r
- 'div': '/',\r
- 'divmod': 'divmod',\r
- 'pow': '**',\r
- 'lshift': '<<',\r
- 'rshift': '>>',\r
- 'and': '&',\r
- 'xor': '^',\r
- 'or': '|',\r
- 'cmp': 'cmp',\r
- 'lt': '<',\r
- 'le': '<=',\r
- 'eq': '==',\r
- 'ne': '!=',\r
- 'gt': '>',\r
- 'ge': '>=',\r
- }\r
-\r
- for name, expr in self.binops.items():\r
- if expr.islower():\r
- expr = expr + "(a, b)"\r
- else:\r
- expr = 'a %s b' % expr\r
- self.binops[name] = expr\r
-\r
- self.unops = {\r
- 'pos': '+',\r
- 'neg': '-',\r
- 'abs': 'abs',\r
- 'invert': '~',\r
- 'int': 'int',\r
- 'long': 'long',\r
- 'float': 'float',\r
- 'oct': 'oct',\r
- 'hex': 'hex',\r
- }\r
-\r
- for name, expr in self.unops.items():\r
- if expr.islower():\r
- expr = expr + "(a)"\r
- else:\r
- expr = '%s a' % expr\r
- self.unops[name] = expr\r
-\r
- def unop_test(self, a, res, expr="len(a)", meth="__len__"):\r
- d = {'a': a}\r
- self.assertEqual(eval(expr, d), res)\r
- t = type(a)\r
- m = getattr(t, meth)\r
-\r
- # Find method in parent class\r
- while meth not in t.__dict__:\r
- t = t.__bases__[0]\r
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound\r
- # method object; the getattr() below obtains its underlying function.\r
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\r
- self.assertEqual(m(a), res)\r
- bm = getattr(a, meth)\r
- self.assertEqual(bm(), res)\r
-\r
- def binop_test(self, a, b, res, expr="a+b", meth="__add__"):\r
- d = {'a': a, 'b': b}\r
-\r
- # XXX Hack so this passes before 2.3 when -Qnew is specified.\r
- if meth == "__div__" and 1/2 == 0.5:\r
- meth = "__truediv__"\r
-\r
- if meth == '__divmod__': pass\r
-\r
- self.assertEqual(eval(expr, d), res)\r
- t = type(a)\r
- m = getattr(t, meth)\r
- while meth not in t.__dict__:\r
- t = t.__bases__[0]\r
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound\r
- # method object; the getattr() below obtains its underlying function.\r
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\r
- self.assertEqual(m(a, b), res)\r
- bm = getattr(a, meth)\r
- self.assertEqual(bm(b), res)\r
-\r
- def ternop_test(self, a, b, c, res, expr="a[b:c]", meth="__getslice__"):\r
- d = {'a': a, 'b': b, 'c': c}\r
- self.assertEqual(eval(expr, d), res)\r
- t = type(a)\r
- m = getattr(t, meth)\r
- while meth not in t.__dict__:\r
- t = t.__bases__[0]\r
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound\r
- # method object; the getattr() below obtains its underlying function.\r
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\r
- self.assertEqual(m(a, b, c), res)\r
- bm = getattr(a, meth)\r
- self.assertEqual(bm(b, c), res)\r
-\r
- def setop_test(self, a, b, res, stmt="a+=b", meth="__iadd__"):\r
- d = {'a': deepcopy(a), 'b': b}\r
- exec stmt in d\r
- self.assertEqual(d['a'], res)\r
- t = type(a)\r
- m = getattr(t, meth)\r
- while meth not in t.__dict__:\r
- t = t.__bases__[0]\r
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound\r
- # method object; the getattr() below obtains its underlying function.\r
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\r
- d['a'] = deepcopy(a)\r
- m(d['a'], b)\r
- self.assertEqual(d['a'], res)\r
- d['a'] = deepcopy(a)\r
- bm = getattr(d['a'], meth)\r
- bm(b)\r
- self.assertEqual(d['a'], res)\r
-\r
- def set2op_test(self, a, b, c, res, stmt="a[b]=c", meth="__setitem__"):\r
- d = {'a': deepcopy(a), 'b': b, 'c': c}\r
- exec stmt in d\r
- self.assertEqual(d['a'], res)\r
- t = type(a)\r
- m = getattr(t, meth)\r
- while meth not in t.__dict__:\r
- t = t.__bases__[0]\r
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound\r
- # method object; the getattr() below obtains its underlying function.\r
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\r
- d['a'] = deepcopy(a)\r
- m(d['a'], b, c)\r
- self.assertEqual(d['a'], res)\r
- d['a'] = deepcopy(a)\r
- bm = getattr(d['a'], meth)\r
- bm(b, c)\r
- self.assertEqual(d['a'], res)\r
-\r
- def set3op_test(self, a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"):\r
- dictionary = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}\r
- exec stmt in dictionary\r
- self.assertEqual(dictionary['a'], res)\r
- t = type(a)\r
- while meth not in t.__dict__:\r
- t = t.__bases__[0]\r
- m = getattr(t, meth)\r
- # in some implementations (e.g. PyPy), 'm' can be a regular unbound\r
- # method object; the getattr() below obtains its underlying function.\r
- self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\r
- dictionary['a'] = deepcopy(a)\r
- m(dictionary['a'], b, c, d)\r
- self.assertEqual(dictionary['a'], res)\r
- dictionary['a'] = deepcopy(a)\r
- bm = getattr(dictionary['a'], meth)\r
- bm(b, c, d)\r
- self.assertEqual(dictionary['a'], res)\r
-\r
- def test_lists(self):\r
- # Testing list operations...\r
- # Asserts are within individual test methods\r
- self.binop_test([1], [2], [1,2], "a+b", "__add__")\r
- self.binop_test([1,2,3], 2, 1, "b in a", "__contains__")\r
- self.binop_test([1,2,3], 4, 0, "b in a", "__contains__")\r
- self.binop_test([1,2,3], 1, 2, "a[b]", "__getitem__")\r
- self.ternop_test([1,2,3], 0, 2, [1,2], "a[b:c]", "__getslice__")\r
- self.setop_test([1], [2], [1,2], "a+=b", "__iadd__")\r
- self.setop_test([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__")\r
- self.unop_test([1,2,3], 3, "len(a)", "__len__")\r
- self.binop_test([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__")\r
- self.binop_test([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__")\r
- self.set2op_test([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__")\r
- self.set3op_test([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d",\r
- "__setslice__")\r
-\r
- def test_dicts(self):\r
- # Testing dict operations...\r
- if hasattr(dict, '__cmp__'): # PyPy has only rich comparison on dicts\r
- self.binop_test({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__")\r
- else:\r
- self.binop_test({1:2}, {2:1}, True, "a < b", "__lt__")\r
- self.binop_test({1:2,3:4}, 1, 1, "b in a", "__contains__")\r
- self.binop_test({1:2,3:4}, 2, 0, "b in a", "__contains__")\r
- self.binop_test({1:2,3:4}, 1, 2, "a[b]", "__getitem__")\r
-\r
- d = {1:2, 3:4}\r
- l1 = []\r
- for i in d.keys():\r
- l1.append(i)\r
- l = []\r
- for i in iter(d):\r
- l.append(i)\r
- self.assertEqual(l, l1)\r
- l = []\r
- for i in d.__iter__():\r
- l.append(i)\r
- self.assertEqual(l, l1)\r
- l = []\r
- for i in dict.__iter__(d):\r
- l.append(i)\r
- self.assertEqual(l, l1)\r
- d = {1:2, 3:4}\r
- self.unop_test(d, 2, "len(a)", "__len__")\r
- self.assertEqual(eval(repr(d), {}), d)\r
- self.assertEqual(eval(d.__repr__(), {}), d)\r
- self.set2op_test({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c",\r
- "__setitem__")\r
-\r
- # Tests for unary and binary operators\r
- def number_operators(self, a, b, skip=[]):\r
- dict = {'a': a, 'b': b}\r
-\r
- for name, expr in self.binops.items():\r
- if name not in skip:\r
- name = "__%s__" % name\r
- if hasattr(a, name):\r
- res = eval(expr, dict)\r
- self.binop_test(a, b, res, expr, name)\r
-\r
- for name, expr in self.unops.items():\r
- if name not in skip:\r
- name = "__%s__" % name\r
- if hasattr(a, name):\r
- res = eval(expr, dict)\r
- self.unop_test(a, res, expr, name)\r
-\r
- def test_ints(self):\r
- # Testing int operations...\r
- self.number_operators(100, 3)\r
- # The following crashes in Python 2.2\r
- self.assertEqual((1).__nonzero__(), 1)\r
- self.assertEqual((0).__nonzero__(), 0)\r
- # This returns 'NotImplemented' in Python 2.2\r
- class C(int):\r
- def __add__(self, other):\r
- return NotImplemented\r
- self.assertEqual(C(5L), 5)\r
- try:\r
- C() + ""\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("NotImplemented should have caused TypeError")\r
- try:\r
- C(sys.maxint+1)\r
- except OverflowError:\r
- pass\r
- else:\r
- self.fail("should have raised OverflowError")\r
-\r
- def test_longs(self):\r
- # Testing long operations...\r
- self.number_operators(100L, 3L)\r
-\r
- def test_floats(self):\r
- # Testing float operations...\r
- self.number_operators(100.0, 3.0)\r
-\r
- def test_complexes(self):\r
- # Testing complex operations...\r
- self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',\r
- 'int', 'long', 'float'])\r
-\r
- class Number(complex):\r
- __slots__ = ['prec']\r
- def __new__(cls, *args, **kwds):\r
- result = complex.__new__(cls, *args)\r
- result.prec = kwds.get('prec', 12)\r
- return result\r
- def __repr__(self):\r
- prec = self.prec\r
- if self.imag == 0.0:\r
- return "%.*g" % (prec, self.real)\r
- if self.real == 0.0:\r
- return "%.*gj" % (prec, self.imag)\r
- return "(%.*g+%.*gj)" % (prec, self.real, prec, self.imag)\r
- __str__ = __repr__\r
-\r
- a = Number(3.14, prec=6)\r
- self.assertEqual(repr(a), "3.14")\r
- self.assertEqual(a.prec, 6)\r
-\r
- a = Number(a, prec=2)\r
- self.assertEqual(repr(a), "3.1")\r
- self.assertEqual(a.prec, 2)\r
-\r
- a = Number(234.5)\r
- self.assertEqual(repr(a), "234.5")\r
- self.assertEqual(a.prec, 12)\r
-\r
- @test_support.impl_detail("the module 'xxsubtype' is internal")\r
- def test_spam_lists(self):\r
- # Testing spamlist operations...\r
- import copy, xxsubtype as spam\r
-\r
- def spamlist(l, memo=None):\r
- import xxsubtype as spam\r
- return spam.spamlist(l)\r
-\r
- # This is an ugly hack:\r
- copy._deepcopy_dispatch[spam.spamlist] = spamlist\r
-\r
- self.binop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b",\r
- "__add__")\r
- self.binop_test(spamlist([1,2,3]), 2, 1, "b in a", "__contains__")\r
- self.binop_test(spamlist([1,2,3]), 4, 0, "b in a", "__contains__")\r
- self.binop_test(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__")\r
- self.ternop_test(spamlist([1,2,3]), 0, 2, spamlist([1,2]), "a[b:c]",\r
- "__getslice__")\r
- self.setop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+=b",\r
- "__iadd__")\r
- self.setop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b",\r
- "__imul__")\r
- self.unop_test(spamlist([1,2,3]), 3, "len(a)", "__len__")\r
- self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b",\r
- "__mul__")\r
- self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a",\r
- "__rmul__")\r
- self.set2op_test(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c",\r
- "__setitem__")\r
- self.set3op_test(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),\r
- spamlist([1,5,6,4]), "a[b:c]=d", "__setslice__")\r
- # Test subclassing\r
- class C(spam.spamlist):\r
- def foo(self): return 1\r
- a = C()\r
- self.assertEqual(a, [])\r
- self.assertEqual(a.foo(), 1)\r
- a.append(100)\r
- self.assertEqual(a, [100])\r
- self.assertEqual(a.getstate(), 0)\r
- a.setstate(42)\r
- self.assertEqual(a.getstate(), 42)\r
-\r
- @test_support.impl_detail("the module 'xxsubtype' is internal")\r
- def test_spam_dicts(self):\r
- # Testing spamdict operations...\r
- import copy, xxsubtype as spam\r
- def spamdict(d, memo=None):\r
- import xxsubtype as spam\r
- sd = spam.spamdict()\r
- for k, v in d.items():\r
- sd[k] = v\r
- return sd\r
- # This is an ugly hack:\r
- copy._deepcopy_dispatch[spam.spamdict] = spamdict\r
-\r
- self.binop_test(spamdict({1:2}), spamdict({2:1}), -1, "cmp(a,b)",\r
- "__cmp__")\r
- self.binop_test(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__")\r
- self.binop_test(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__")\r
- self.binop_test(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__")\r
- d = spamdict({1:2,3:4})\r
- l1 = []\r
- for i in d.keys():\r
- l1.append(i)\r
- l = []\r
- for i in iter(d):\r
- l.append(i)\r
- self.assertEqual(l, l1)\r
- l = []\r
- for i in d.__iter__():\r
- l.append(i)\r
- self.assertEqual(l, l1)\r
- l = []\r
- for i in type(spamdict({})).__iter__(d):\r
- l.append(i)\r
- self.assertEqual(l, l1)\r
- straightd = {1:2, 3:4}\r
- spamd = spamdict(straightd)\r
- self.unop_test(spamd, 2, "len(a)", "__len__")\r
- self.unop_test(spamd, repr(straightd), "repr(a)", "__repr__")\r
- self.set2op_test(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}),\r
- "a[b]=c", "__setitem__")\r
- # Test subclassing\r
- class C(spam.spamdict):\r
- def foo(self): return 1\r
- a = C()\r
- self.assertEqual(a.items(), [])\r
- self.assertEqual(a.foo(), 1)\r
- a['foo'] = 'bar'\r
- self.assertEqual(a.items(), [('foo', 'bar')])\r
- self.assertEqual(a.getstate(), 0)\r
- a.setstate(100)\r
- self.assertEqual(a.getstate(), 100)\r
-\r
-class ClassPropertiesAndMethods(unittest.TestCase):\r
-\r
- def test_python_dicts(self):\r
- # Testing Python subclass of dict...\r
- self.assertTrue(issubclass(dict, dict))\r
- self.assertIsInstance({}, dict)\r
- d = dict()\r
- self.assertEqual(d, {})\r
- self.assertTrue(d.__class__ is dict)\r
- self.assertIsInstance(d, dict)\r
- class C(dict):\r
- state = -1\r
- def __init__(self_local, *a, **kw):\r
- if a:\r
- self.assertEqual(len(a), 1)\r
- self_local.state = a[0]\r
- if kw:\r
- for k, v in kw.items():\r
- self_local[v] = k\r
- def __getitem__(self, key):\r
- return self.get(key, 0)\r
- def __setitem__(self_local, key, value):\r
- self.assertIsInstance(key, type(0))\r
- dict.__setitem__(self_local, key, value)\r
- def setstate(self, state):\r
- self.state = state\r
- def getstate(self):\r
- return self.state\r
- self.assertTrue(issubclass(C, dict))\r
- a1 = C(12)\r
- self.assertEqual(a1.state, 12)\r
- a2 = C(foo=1, bar=2)\r
- self.assertEqual(a2[1] == 'foo' and a2[2], 'bar')\r
- a = C()\r
- self.assertEqual(a.state, -1)\r
- self.assertEqual(a.getstate(), -1)\r
- a.setstate(0)\r
- self.assertEqual(a.state, 0)\r
- self.assertEqual(a.getstate(), 0)\r
- a.setstate(10)\r
- self.assertEqual(a.state, 10)\r
- self.assertEqual(a.getstate(), 10)\r
- self.assertEqual(a[42], 0)\r
- a[42] = 24\r
- self.assertEqual(a[42], 24)\r
- N = 50\r
- for i in range(N):\r
- a[i] = C()\r
- for j in range(N):\r
- a[i][j] = i*j\r
- for i in range(N):\r
- for j in range(N):\r
- self.assertEqual(a[i][j], i*j)\r
-\r
- def test_python_lists(self):\r
- # Testing Python subclass of list...\r
- class C(list):\r
- def __getitem__(self, i):\r
- return list.__getitem__(self, i) + 100\r
- def __getslice__(self, i, j):\r
- return (i, j)\r
- a = C()\r
- a.extend([0,1,2])\r
- self.assertEqual(a[0], 100)\r
- self.assertEqual(a[1], 101)\r
- self.assertEqual(a[2], 102)\r
- self.assertEqual(a[100:200], (100,200))\r
-\r
- def test_metaclass(self):\r
- # Testing __metaclass__...\r
- class C:\r
- __metaclass__ = type\r
- def __init__(self):\r
- self.__state = 0\r
- def getstate(self):\r
- return self.__state\r
- def setstate(self, state):\r
- self.__state = state\r
- a = C()\r
- self.assertEqual(a.getstate(), 0)\r
- a.setstate(10)\r
- self.assertEqual(a.getstate(), 10)\r
- class D:\r
- class __metaclass__(type):\r
- def myself(cls): return cls\r
- self.assertEqual(D.myself(), D)\r
- d = D()\r
- self.assertEqual(d.__class__, D)\r
- class M1(type):\r
- def __new__(cls, name, bases, dict):\r
- dict['__spam__'] = 1\r
- return type.__new__(cls, name, bases, dict)\r
- class C:\r
- __metaclass__ = M1\r
- self.assertEqual(C.__spam__, 1)\r
- c = C()\r
- self.assertEqual(c.__spam__, 1)\r
-\r
- class _instance(object):\r
- pass\r
- class M2(object):\r
- @staticmethod\r
- def __new__(cls, name, bases, dict):\r
- self = object.__new__(cls)\r
- self.name = name\r
- self.bases = bases\r
- self.dict = dict\r
- return self\r
- def __call__(self):\r
- it = _instance()\r
- # Early binding of methods\r
- for key in self.dict:\r
- if key.startswith("__"):\r
- continue\r
- setattr(it, key, self.dict[key].__get__(it, self))\r
- return it\r
- class C:\r
- __metaclass__ = M2\r
- def spam(self):\r
- return 42\r
- self.assertEqual(C.name, 'C')\r
- self.assertEqual(C.bases, ())\r
- self.assertIn('spam', C.dict)\r
- c = C()\r
- self.assertEqual(c.spam(), 42)\r
-\r
- # More metaclass examples\r
-\r
- class autosuper(type):\r
- # Automatically add __super to the class\r
- # This trick only works for dynamic classes\r
- def __new__(metaclass, name, bases, dict):\r
- cls = super(autosuper, metaclass).__new__(metaclass,\r
- name, bases, dict)\r
- # Name mangling for __super removes leading underscores\r
- while name[:1] == "_":\r
- name = name[1:]\r
- if name:\r
- name = "_%s__super" % name\r
- else:\r
- name = "__super"\r
- setattr(cls, name, super(cls))\r
- return cls\r
- class A:\r
- __metaclass__ = autosuper\r
- def meth(self):\r
- return "A"\r
- class B(A):\r
- def meth(self):\r
- return "B" + self.__super.meth()\r
- class C(A):\r
- def meth(self):\r
- return "C" + self.__super.meth()\r
- class D(C, B):\r
- def meth(self):\r
- return "D" + self.__super.meth()\r
- self.assertEqual(D().meth(), "DCBA")\r
- class E(B, C):\r
- def meth(self):\r
- return "E" + self.__super.meth()\r
- self.assertEqual(E().meth(), "EBCA")\r
-\r
- class autoproperty(type):\r
- # Automatically create property attributes when methods\r
- # named _get_x and/or _set_x are found\r
- def __new__(metaclass, name, bases, dict):\r
- hits = {}\r
- for key, val in dict.iteritems():\r
- if key.startswith("_get_"):\r
- key = key[5:]\r
- get, set = hits.get(key, (None, None))\r
- get = val\r
- hits[key] = get, set\r
- elif key.startswith("_set_"):\r
- key = key[5:]\r
- get, set = hits.get(key, (None, None))\r
- set = val\r
- hits[key] = get, set\r
- for key, (get, set) in hits.iteritems():\r
- dict[key] = property(get, set)\r
- return super(autoproperty, metaclass).__new__(metaclass,\r
- name, bases, dict)\r
- class A:\r
- __metaclass__ = autoproperty\r
- def _get_x(self):\r
- return -self.__x\r
- def _set_x(self, x):\r
- self.__x = -x\r
- a = A()\r
- self.assertTrue(not hasattr(a, "x"))\r
- a.x = 12\r
- self.assertEqual(a.x, 12)\r
- self.assertEqual(a._A__x, -12)\r
-\r
- class multimetaclass(autoproperty, autosuper):\r
- # Merge of multiple cooperating metaclasses\r
- pass\r
- class A:\r
- __metaclass__ = multimetaclass\r
- def _get_x(self):\r
- return "A"\r
- class B(A):\r
- def _get_x(self):\r
- return "B" + self.__super._get_x()\r
- class C(A):\r
- def _get_x(self):\r
- return "C" + self.__super._get_x()\r
- class D(C, B):\r
- def _get_x(self):\r
- return "D" + self.__super._get_x()\r
- self.assertEqual(D().x, "DCBA")\r
-\r
- # Make sure type(x) doesn't call x.__class__.__init__\r
- class T(type):\r
- counter = 0\r
- def __init__(self, *args):\r
- T.counter += 1\r
- class C:\r
- __metaclass__ = T\r
- self.assertEqual(T.counter, 1)\r
- a = C()\r
- self.assertEqual(type(a), C)\r
- self.assertEqual(T.counter, 1)\r
-\r
- class C(object): pass\r
- c = C()\r
- try: c()\r
- except TypeError: pass\r
- else: self.fail("calling object w/o call method should raise "\r
- "TypeError")\r
-\r
- # Testing code to find most derived baseclass\r
- class A(type):\r
- def __new__(*args, **kwargs):\r
- return type.__new__(*args, **kwargs)\r
-\r
- class B(object):\r
- pass\r
-\r
- class C(object):\r
- __metaclass__ = A\r
-\r
- # The most derived metaclass of D is A rather than type.\r
- class D(B, C):\r
- pass\r
-\r
- def test_module_subclasses(self):\r
- # Testing Python subclass of module...\r
- log = []\r
- MT = type(sys)\r
- class MM(MT):\r
- def __init__(self, name):\r
- MT.__init__(self, name)\r
- def __getattribute__(self, name):\r
- log.append(("getattr", name))\r
- return MT.__getattribute__(self, name)\r
- def __setattr__(self, name, value):\r
- log.append(("setattr", name, value))\r
- MT.__setattr__(self, name, value)\r
- def __delattr__(self, name):\r
- log.append(("delattr", name))\r
- MT.__delattr__(self, name)\r
- a = MM("a")\r
- a.foo = 12\r
- x = a.foo\r
- del a.foo\r
- self.assertEqual(log, [("setattr", "foo", 12),\r
- ("getattr", "foo"),\r
- ("delattr", "foo")])\r
-\r
- # http://python.org/sf/1174712\r
- try:\r
- class Module(types.ModuleType, str):\r
- pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("inheriting from ModuleType and str at the same time "\r
- "should fail")\r
-\r
- def test_multiple_inheritence(self):\r
- # Testing multiple inheritance...\r
- class C(object):\r
- def __init__(self):\r
- self.__state = 0\r
- def getstate(self):\r
- return self.__state\r
- def setstate(self, state):\r
- self.__state = state\r
- a = C()\r
- self.assertEqual(a.getstate(), 0)\r
- a.setstate(10)\r
- self.assertEqual(a.getstate(), 10)\r
- class D(dict, C):\r
- def __init__(self):\r
- type({}).__init__(self)\r
- C.__init__(self)\r
- d = D()\r
- self.assertEqual(d.keys(), [])\r
- d["hello"] = "world"\r
- self.assertEqual(d.items(), [("hello", "world")])\r
- self.assertEqual(d["hello"], "world")\r
- self.assertEqual(d.getstate(), 0)\r
- d.setstate(10)\r
- self.assertEqual(d.getstate(), 10)\r
- self.assertEqual(D.__mro__, (D, dict, C, object))\r
-\r
- # SF bug #442833\r
- class Node(object):\r
- def __int__(self):\r
- return int(self.foo())\r
- def foo(self):\r
- return "23"\r
- class Frag(Node, list):\r
- def foo(self):\r
- return "42"\r
- self.assertEqual(Node().__int__(), 23)\r
- self.assertEqual(int(Node()), 23)\r
- self.assertEqual(Frag().__int__(), 42)\r
- self.assertEqual(int(Frag()), 42)\r
-\r
- # MI mixing classic and new-style classes.\r
-\r
- class A:\r
- x = 1\r
-\r
- class B(A):\r
- pass\r
-\r
- class C(A):\r
- x = 2\r
-\r
- class D(B, C):\r
- pass\r
- self.assertEqual(D.x, 1)\r
-\r
- # Classic MRO is preserved for a classic base class.\r
- class E(D, object):\r
- pass\r
- self.assertEqual(E.__mro__, (E, D, B, A, C, object))\r
- self.assertEqual(E.x, 1)\r
-\r
- # But with a mix of classic bases, their MROs are combined using\r
- # new-style MRO.\r
- class F(B, C, object):\r
- pass\r
- self.assertEqual(F.__mro__, (F, B, C, A, object))\r
- self.assertEqual(F.x, 2)\r
-\r
- # Try something else.\r
- class C:\r
- def cmethod(self):\r
- return "C a"\r
- def all_method(self):\r
- return "C b"\r
-\r
- class M1(C, object):\r
- def m1method(self):\r
- return "M1 a"\r
- def all_method(self):\r
- return "M1 b"\r
-\r
- self.assertEqual(M1.__mro__, (M1, C, object))\r
- m = M1()\r
- self.assertEqual(m.cmethod(), "C a")\r
- self.assertEqual(m.m1method(), "M1 a")\r
- self.assertEqual(m.all_method(), "M1 b")\r
-\r
- class D(C):\r
- def dmethod(self):\r
- return "D a"\r
- def all_method(self):\r
- return "D b"\r
-\r
- class M2(D, object):\r
- def m2method(self):\r
- return "M2 a"\r
- def all_method(self):\r
- return "M2 b"\r
-\r
- self.assertEqual(M2.__mro__, (M2, D, C, object))\r
- m = M2()\r
- self.assertEqual(m.cmethod(), "C a")\r
- self.assertEqual(m.dmethod(), "D a")\r
- self.assertEqual(m.m2method(), "M2 a")\r
- self.assertEqual(m.all_method(), "M2 b")\r
-\r
- class M3(M1, M2, object):\r
- def m3method(self):\r
- return "M3 a"\r
- def all_method(self):\r
- return "M3 b"\r
- self.assertEqual(M3.__mro__, (M3, M1, M2, D, C, object))\r
- m = M3()\r
- self.assertEqual(m.cmethod(), "C a")\r
- self.assertEqual(m.dmethod(), "D a")\r
- self.assertEqual(m.m1method(), "M1 a")\r
- self.assertEqual(m.m2method(), "M2 a")\r
- self.assertEqual(m.m3method(), "M3 a")\r
- self.assertEqual(m.all_method(), "M3 b")\r
-\r
- class Classic:\r
- pass\r
- try:\r
- class New(Classic):\r
- __metaclass__ = type\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("new class with only classic bases - shouldn't be")\r
-\r
- def test_diamond_inheritence(self):\r
- # Testing multiple inheritance special cases...\r
- class A(object):\r
- def spam(self): return "A"\r
- self.assertEqual(A().spam(), "A")\r
- class B(A):\r
- def boo(self): return "B"\r
- def spam(self): return "B"\r
- self.assertEqual(B().spam(), "B")\r
- self.assertEqual(B().boo(), "B")\r
- class C(A):\r
- def boo(self): return "C"\r
- self.assertEqual(C().spam(), "A")\r
- self.assertEqual(C().boo(), "C")\r
- class D(B, C): pass\r
- self.assertEqual(D().spam(), "B")\r
- self.assertEqual(D().boo(), "B")\r
- self.assertEqual(D.__mro__, (D, B, C, A, object))\r
- class E(C, B): pass\r
- self.assertEqual(E().spam(), "B")\r
- self.assertEqual(E().boo(), "C")\r
- self.assertEqual(E.__mro__, (E, C, B, A, object))\r
- # MRO order disagreement\r
- try:\r
- class F(D, E): pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected MRO order disagreement (F)")\r
- try:\r
- class G(E, D): pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected MRO order disagreement (G)")\r
-\r
- # see thread python-dev/2002-October/029035.html\r
- def test_ex5_from_c3_switch(self):\r
- # Testing ex5 from C3 switch discussion...\r
- class A(object): pass\r
- class B(object): pass\r
- class C(object): pass\r
- class X(A): pass\r
- class Y(A): pass\r
- class Z(X,B,Y,C): pass\r
- self.assertEqual(Z.__mro__, (Z, X, B, Y, A, C, object))\r
-\r
- # see "A Monotonic Superclass Linearization for Dylan",\r
- # by Kim Barrett et al. (OOPSLA 1996)\r
- def test_monotonicity(self):\r
- # Testing MRO monotonicity...\r
- class Boat(object): pass\r
- class DayBoat(Boat): pass\r
- class WheelBoat(Boat): pass\r
- class EngineLess(DayBoat): pass\r
- class SmallMultihull(DayBoat): pass\r
- class PedalWheelBoat(EngineLess,WheelBoat): pass\r
- class SmallCatamaran(SmallMultihull): pass\r
- class Pedalo(PedalWheelBoat,SmallCatamaran): pass\r
-\r
- self.assertEqual(PedalWheelBoat.__mro__,\r
- (PedalWheelBoat, EngineLess, DayBoat, WheelBoat, Boat, object))\r
- self.assertEqual(SmallCatamaran.__mro__,\r
- (SmallCatamaran, SmallMultihull, DayBoat, Boat, object))\r
- self.assertEqual(Pedalo.__mro__,\r
- (Pedalo, PedalWheelBoat, EngineLess, SmallCatamaran,\r
- SmallMultihull, DayBoat, WheelBoat, Boat, object))\r
-\r
- # see "A Monotonic Superclass Linearization for Dylan",\r
- # by Kim Barrett et al. (OOPSLA 1996)\r
- def test_consistency_with_epg(self):\r
- # Testing consistency with EPG...\r
- class Pane(object): pass\r
- class ScrollingMixin(object): pass\r
- class EditingMixin(object): pass\r
- class ScrollablePane(Pane,ScrollingMixin): pass\r
- class EditablePane(Pane,EditingMixin): pass\r
- class EditableScrollablePane(ScrollablePane,EditablePane): pass\r
-\r
- self.assertEqual(EditableScrollablePane.__mro__,\r
- (EditableScrollablePane, ScrollablePane, EditablePane, Pane,\r
- ScrollingMixin, EditingMixin, object))\r
-\r
- def test_mro_disagreement(self):\r
- # Testing error messages for MRO disagreement...\r
- mro_err_msg = """Cannot create a consistent method resolution\r
-order (MRO) for bases """\r
-\r
- def raises(exc, expected, callable, *args):\r
- try:\r
- callable(*args)\r
- except exc, msg:\r
- # the exact msg is generally considered an impl detail\r
- if test_support.check_impl_detail():\r
- if not str(msg).startswith(expected):\r
- self.fail("Message %r, expected %r" %\r
- (str(msg), expected))\r
- else:\r
- self.fail("Expected %s" % exc)\r
-\r
- class A(object): pass\r
- class B(A): pass\r
- class C(object): pass\r
-\r
- # Test some very simple errors\r
- raises(TypeError, "duplicate base class A",\r
- type, "X", (A, A), {})\r
- raises(TypeError, mro_err_msg,\r
- type, "X", (A, B), {})\r
- raises(TypeError, mro_err_msg,\r
- type, "X", (A, C, B), {})\r
- # Test a slightly more complex error\r
- class GridLayout(object): pass\r
- class HorizontalGrid(GridLayout): pass\r
- class VerticalGrid(GridLayout): pass\r
- class HVGrid(HorizontalGrid, VerticalGrid): pass\r
- class VHGrid(VerticalGrid, HorizontalGrid): pass\r
- raises(TypeError, mro_err_msg,\r
- type, "ConfusedGrid", (HVGrid, VHGrid), {})\r
-\r
- def test_object_class(self):\r
- # Testing object class...\r
- a = object()\r
- self.assertEqual(a.__class__, object)\r
- self.assertEqual(type(a), object)\r
- b = object()\r
- self.assertNotEqual(a, b)\r
- self.assertFalse(hasattr(a, "foo"))\r
- try:\r
- a.foo = 12\r
- except (AttributeError, TypeError):\r
- pass\r
- else:\r
- self.fail("object() should not allow setting a foo attribute")\r
- self.assertFalse(hasattr(object(), "__dict__"))\r
-\r
- class Cdict(object):\r
- pass\r
- x = Cdict()\r
- self.assertEqual(x.__dict__, {})\r
- x.foo = 1\r
- self.assertEqual(x.foo, 1)\r
- self.assertEqual(x.__dict__, {'foo': 1})\r
-\r
- def test_slots(self):\r
- # Testing __slots__...\r
- class C0(object):\r
- __slots__ = []\r
- x = C0()\r
- self.assertFalse(hasattr(x, "__dict__"))\r
- self.assertFalse(hasattr(x, "foo"))\r
-\r
- class C1(object):\r
- __slots__ = ['a']\r
- x = C1()\r
- self.assertFalse(hasattr(x, "__dict__"))\r
- self.assertFalse(hasattr(x, "a"))\r
- x.a = 1\r
- self.assertEqual(x.a, 1)\r
- x.a = None\r
- self.assertEqual(x.a, None)\r
- del x.a\r
- self.assertFalse(hasattr(x, "a"))\r
-\r
- class C3(object):\r
- __slots__ = ['a', 'b', 'c']\r
- x = C3()\r
- self.assertFalse(hasattr(x, "__dict__"))\r
- self.assertFalse(hasattr(x, 'a'))\r
- self.assertFalse(hasattr(x, 'b'))\r
- self.assertFalse(hasattr(x, 'c'))\r
- x.a = 1\r
- x.b = 2\r
- x.c = 3\r
- self.assertEqual(x.a, 1)\r
- self.assertEqual(x.b, 2)\r
- self.assertEqual(x.c, 3)\r
-\r
- class C4(object):\r
- """Validate name mangling"""\r
- __slots__ = ['__a']\r
- def __init__(self, value):\r
- self.__a = value\r
- def get(self):\r
- return self.__a\r
- x = C4(5)\r
- self.assertFalse(hasattr(x, '__dict__'))\r
- self.assertFalse(hasattr(x, '__a'))\r
- self.assertEqual(x.get(), 5)\r
- try:\r
- x.__a = 6\r
- except AttributeError:\r
- pass\r
- else:\r
- self.fail("Double underscored names not mangled")\r
-\r
- # Make sure slot names are proper identifiers\r
- try:\r
- class C(object):\r
- __slots__ = [None]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("[None] slots not caught")\r
- try:\r
- class C(object):\r
- __slots__ = ["foo bar"]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("['foo bar'] slots not caught")\r
- try:\r
- class C(object):\r
- __slots__ = ["foo\0bar"]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("['foo\\0bar'] slots not caught")\r
- try:\r
- class C(object):\r
- __slots__ = ["1"]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("['1'] slots not caught")\r
- try:\r
- class C(object):\r
- __slots__ = [""]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("[''] slots not caught")\r
- class C(object):\r
- __slots__ = ["a", "a_b", "_a", "A0123456789Z"]\r
- # XXX(nnorwitz): was there supposed to be something tested\r
- # from the class above?\r
-\r
- # Test a single string is not expanded as a sequence.\r
- class C(object):\r
- __slots__ = "abc"\r
- c = C()\r
- c.abc = 5\r
- self.assertEqual(c.abc, 5)\r
-\r
- # Test unicode slot names\r
- try:\r
- unicode\r
- except NameError:\r
- pass\r
- else:\r
- # Test a single unicode string is not expanded as a sequence.\r
- class C(object):\r
- __slots__ = unicode("abc")\r
- c = C()\r
- c.abc = 5\r
- self.assertEqual(c.abc, 5)\r
-\r
- # _unicode_to_string used to modify slots in certain circumstances\r
- slots = (unicode("foo"), unicode("bar"))\r
- class C(object):\r
- __slots__ = slots\r
- x = C()\r
- x.foo = 5\r
- self.assertEqual(x.foo, 5)\r
- self.assertEqual(type(slots[0]), unicode)\r
- # this used to leak references\r
- try:\r
- class C(object):\r
- __slots__ = [unichr(128)]\r
- except (TypeError, UnicodeEncodeError):\r
- pass\r
- else:\r
- self.fail("[unichr(128)] slots not caught")\r
-\r
- # Test leaks\r
- class Counted(object):\r
- counter = 0 # counts the number of instances alive\r
- def __init__(self):\r
- Counted.counter += 1\r
- def __del__(self):\r
- Counted.counter -= 1\r
- class C(object):\r
- __slots__ = ['a', 'b', 'c']\r
- x = C()\r
- x.a = Counted()\r
- x.b = Counted()\r
- x.c = Counted()\r
- self.assertEqual(Counted.counter, 3)\r
- del x\r
- test_support.gc_collect()\r
- self.assertEqual(Counted.counter, 0)\r
- class D(C):\r
- pass\r
- x = D()\r
- x.a = Counted()\r
- x.z = Counted()\r
- self.assertEqual(Counted.counter, 2)\r
- del x\r
- test_support.gc_collect()\r
- self.assertEqual(Counted.counter, 0)\r
- class E(D):\r
- __slots__ = ['e']\r
- x = E()\r
- x.a = Counted()\r
- x.z = Counted()\r
- x.e = Counted()\r
- self.assertEqual(Counted.counter, 3)\r
- del x\r
- test_support.gc_collect()\r
- self.assertEqual(Counted.counter, 0)\r
-\r
- # Test cyclical leaks [SF bug 519621]\r
- class F(object):\r
- __slots__ = ['a', 'b']\r
- s = F()\r
- s.a = [Counted(), s]\r
- self.assertEqual(Counted.counter, 1)\r
- s = None\r
- test_support.gc_collect()\r
- self.assertEqual(Counted.counter, 0)\r
-\r
- # Test lookup leaks [SF bug 572567]\r
- import gc\r
- if hasattr(gc, 'get_objects'):\r
- class G(object):\r
- def __cmp__(self, other):\r
- return 0\r
- __hash__ = None # Silence Py3k warning\r
- g = G()\r
- orig_objects = len(gc.get_objects())\r
- for i in xrange(10):\r
- g==g\r
- new_objects = len(gc.get_objects())\r
- self.assertEqual(orig_objects, new_objects)\r
-\r
- class H(object):\r
- __slots__ = ['a', 'b']\r
- def __init__(self):\r
- self.a = 1\r
- self.b = 2\r
- def __del__(self_):\r
- self.assertEqual(self_.a, 1)\r
- self.assertEqual(self_.b, 2)\r
- with test_support.captured_output('stderr') as s:\r
- h = H()\r
- del h\r
- self.assertEqual(s.getvalue(), '')\r
-\r
- class X(object):\r
- __slots__ = "a"\r
- with self.assertRaises(AttributeError):\r
- del X().a\r
-\r
- def test_slots_special(self):\r
- # Testing __dict__ and __weakref__ in __slots__...\r
- class D(object):\r
- __slots__ = ["__dict__"]\r
- a = D()\r
- self.assertTrue(hasattr(a, "__dict__"))\r
- self.assertFalse(hasattr(a, "__weakref__"))\r
- a.foo = 42\r
- self.assertEqual(a.__dict__, {"foo": 42})\r
-\r
- class W(object):\r
- __slots__ = ["__weakref__"]\r
- a = W()\r
- self.assertTrue(hasattr(a, "__weakref__"))\r
- self.assertFalse(hasattr(a, "__dict__"))\r
- try:\r
- a.foo = 42\r
- except AttributeError:\r
- pass\r
- else:\r
- self.fail("shouldn't be allowed to set a.foo")\r
-\r
- class C1(W, D):\r
- __slots__ = []\r
- a = C1()\r
- self.assertTrue(hasattr(a, "__dict__"))\r
- self.assertTrue(hasattr(a, "__weakref__"))\r
- a.foo = 42\r
- self.assertEqual(a.__dict__, {"foo": 42})\r
-\r
- class C2(D, W):\r
- __slots__ = []\r
- a = C2()\r
- self.assertTrue(hasattr(a, "__dict__"))\r
- self.assertTrue(hasattr(a, "__weakref__"))\r
- a.foo = 42\r
- self.assertEqual(a.__dict__, {"foo": 42})\r
-\r
- def test_slots_descriptor(self):\r
- # Issue2115: slot descriptors did not correctly check\r
- # the type of the given object\r
- import abc\r
- class MyABC:\r
- __metaclass__ = abc.ABCMeta\r
- __slots__ = "a"\r
-\r
- class Unrelated(object):\r
- pass\r
- MyABC.register(Unrelated)\r
-\r
- u = Unrelated()\r
- self.assertIsInstance(u, MyABC)\r
-\r
- # This used to crash\r
- self.assertRaises(TypeError, MyABC.a.__set__, u, 3)\r
-\r
- def test_metaclass_cmp(self):\r
- # See bug 7491.\r
- class M(type):\r
- def __cmp__(self, other):\r
- return -1\r
- class X(object):\r
- __metaclass__ = M\r
- self.assertTrue(X < M)\r
-\r
- def test_dynamics(self):\r
- # Testing class attribute propagation...\r
- class D(object):\r
- pass\r
- class E(D):\r
- pass\r
- class F(D):\r
- pass\r
- D.foo = 1\r
- self.assertEqual(D.foo, 1)\r
- # Test that dynamic attributes are inherited\r
- self.assertEqual(E.foo, 1)\r
- self.assertEqual(F.foo, 1)\r
- # Test dynamic instances\r
- class C(object):\r
- pass\r
- a = C()\r
- self.assertFalse(hasattr(a, "foobar"))\r
- C.foobar = 2\r
- self.assertEqual(a.foobar, 2)\r
- C.method = lambda self: 42\r
- self.assertEqual(a.method(), 42)\r
- C.__repr__ = lambda self: "C()"\r
- self.assertEqual(repr(a), "C()")\r
- C.__int__ = lambda self: 100\r
- self.assertEqual(int(a), 100)\r
- self.assertEqual(a.foobar, 2)\r
- self.assertFalse(hasattr(a, "spam"))\r
- def mygetattr(self, name):\r
- if name == "spam":\r
- return "spam"\r
- raise AttributeError\r
- C.__getattr__ = mygetattr\r
- self.assertEqual(a.spam, "spam")\r
- a.new = 12\r
- self.assertEqual(a.new, 12)\r
- def mysetattr(self, name, value):\r
- if name == "spam":\r
- raise AttributeError\r
- return object.__setattr__(self, name, value)\r
- C.__setattr__ = mysetattr\r
- try:\r
- a.spam = "not spam"\r
- except AttributeError:\r
- pass\r
- else:\r
- self.fail("expected AttributeError")\r
- self.assertEqual(a.spam, "spam")\r
- class D(C):\r
- pass\r
- d = D()\r
- d.foo = 1\r
- self.assertEqual(d.foo, 1)\r
-\r
- # Test handling of int*seq and seq*int\r
- class I(int):\r
- pass\r
- self.assertEqual("a"*I(2), "aa")\r
- self.assertEqual(I(2)*"a", "aa")\r
- self.assertEqual(2*I(3), 6)\r
- self.assertEqual(I(3)*2, 6)\r
- self.assertEqual(I(3)*I(2), 6)\r
-\r
- # Test handling of long*seq and seq*long\r
- class L(long):\r
- pass\r
- self.assertEqual("a"*L(2L), "aa")\r
- self.assertEqual(L(2L)*"a", "aa")\r
- self.assertEqual(2*L(3), 6)\r
- self.assertEqual(L(3)*2, 6)\r
- self.assertEqual(L(3)*L(2), 6)\r
-\r
- # Test comparison of classes with dynamic metaclasses\r
- class dynamicmetaclass(type):\r
- pass\r
- class someclass:\r
- __metaclass__ = dynamicmetaclass\r
- self.assertNotEqual(someclass, object)\r
-\r
- def test_errors(self):\r
- # Testing errors...\r
- try:\r
- class C(list, dict):\r
- pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("inheritance from both list and dict should be illegal")\r
-\r
- try:\r
- class C(object, None):\r
- pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("inheritance from non-type should be illegal")\r
- class Classic:\r
- pass\r
-\r
- try:\r
- class C(type(len)):\r
- pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("inheritance from CFunction should be illegal")\r
-\r
- try:\r
- class C(object):\r
- __slots__ = 1\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("__slots__ = 1 should be illegal")\r
-\r
- try:\r
- class C(object):\r
- __slots__ = [1]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("__slots__ = [1] should be illegal")\r
-\r
- class M1(type):\r
- pass\r
- class M2(type):\r
- pass\r
- class A1(object):\r
- __metaclass__ = M1\r
- class A2(object):\r
- __metaclass__ = M2\r
- try:\r
- class B(A1, A2):\r
- pass\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("finding the most derived metaclass should have failed")\r
-\r
- def test_classmethods(self):\r
- # Testing class methods...\r
- class C(object):\r
- def foo(*a): return a\r
- goo = classmethod(foo)\r
- c = C()\r
- self.assertEqual(C.goo(1), (C, 1))\r
- self.assertEqual(c.goo(1), (C, 1))\r
- self.assertEqual(c.foo(1), (c, 1))\r
- class D(C):\r
- pass\r
- d = D()\r
- self.assertEqual(D.goo(1), (D, 1))\r
- self.assertEqual(d.goo(1), (D, 1))\r
- self.assertEqual(d.foo(1), (d, 1))\r
- self.assertEqual(D.foo(d, 1), (d, 1))\r
- # Test for a specific crash (SF bug 528132)\r
- def f(cls, arg): return (cls, arg)\r
- ff = classmethod(f)\r
- self.assertEqual(ff.__get__(0, int)(42), (int, 42))\r
- self.assertEqual(ff.__get__(0)(42), (int, 42))\r
-\r
- # Test super() with classmethods (SF bug 535444)\r
- self.assertEqual(C.goo.im_self, C)\r
- self.assertEqual(D.goo.im_self, D)\r
- self.assertEqual(super(D,D).goo.im_self, D)\r
- self.assertEqual(super(D,d).goo.im_self, D)\r
- self.assertEqual(super(D,D).goo(), (D,))\r
- self.assertEqual(super(D,d).goo(), (D,))\r
-\r
- # Verify that a non-callable will raise\r
- meth = classmethod(1).__get__(1)\r
- self.assertRaises(TypeError, meth)\r
-\r
- # Verify that classmethod() doesn't allow keyword args\r
- try:\r
- classmethod(f, kw=1)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("classmethod shouldn't accept keyword args")\r
-\r
- @test_support.impl_detail("the module 'xxsubtype' is internal")\r
- def test_classmethods_in_c(self):\r
- # Testing C-based class methods...\r
- import xxsubtype as spam\r
- a = (1, 2, 3)\r
- d = {'abc': 123}\r
- x, a1, d1 = spam.spamlist.classmeth(*a, **d)\r
- self.assertEqual(x, spam.spamlist)\r
- self.assertEqual(a, a1)\r
- self.assertEqual(d, d1)\r
- x, a1, d1 = spam.spamlist().classmeth(*a, **d)\r
- self.assertEqual(x, spam.spamlist)\r
- self.assertEqual(a, a1)\r
- self.assertEqual(d, d1)\r
-\r
- def test_staticmethods(self):\r
- # Testing static methods...\r
- class C(object):\r
- def foo(*a): return a\r
- goo = staticmethod(foo)\r
- c = C()\r
- self.assertEqual(C.goo(1), (1,))\r
- self.assertEqual(c.goo(1), (1,))\r
- self.assertEqual(c.foo(1), (c, 1,))\r
- class D(C):\r
- pass\r
- d = D()\r
- self.assertEqual(D.goo(1), (1,))\r
- self.assertEqual(d.goo(1), (1,))\r
- self.assertEqual(d.foo(1), (d, 1))\r
- self.assertEqual(D.foo(d, 1), (d, 1))\r
-\r
- @test_support.impl_detail("the module 'xxsubtype' is internal")\r
- def test_staticmethods_in_c(self):\r
- # Testing C-based static methods...\r
- import xxsubtype as spam\r
- a = (1, 2, 3)\r
- d = {"abc": 123}\r
- x, a1, d1 = spam.spamlist.staticmeth(*a, **d)\r
- self.assertEqual(x, None)\r
- self.assertEqual(a, a1)\r
- self.assertEqual(d, d1)\r
- x, a1, d2 = spam.spamlist().staticmeth(*a, **d)\r
- self.assertEqual(x, None)\r
- self.assertEqual(a, a1)\r
- self.assertEqual(d, d1)\r
-\r
- def test_classic(self):\r
- # Testing classic classes...\r
- class C:\r
- def foo(*a): return a\r
- goo = classmethod(foo)\r
- c = C()\r
- self.assertEqual(C.goo(1), (C, 1))\r
- self.assertEqual(c.goo(1), (C, 1))\r
- self.assertEqual(c.foo(1), (c, 1))\r
- class D(C):\r
- pass\r
- d = D()\r
- self.assertEqual(D.goo(1), (D, 1))\r
- self.assertEqual(d.goo(1), (D, 1))\r
- self.assertEqual(d.foo(1), (d, 1))\r
- self.assertEqual(D.foo(d, 1), (d, 1))\r
- class E: # *not* subclassing from C\r
- foo = C.foo\r
- self.assertEqual(E().foo, C.foo) # i.e., unbound\r
- self.assertTrue(repr(C.foo.__get__(C())).startswith("<bound method "))\r
-\r
- def test_compattr(self):\r
- # Testing computed attributes...\r
- class C(object):\r
- class computed_attribute(object):\r
- def __init__(self, get, set=None, delete=None):\r
- self.__get = get\r
- self.__set = set\r
- self.__delete = delete\r
- def __get__(self, obj, type=None):\r
- return self.__get(obj)\r
- def __set__(self, obj, value):\r
- return self.__set(obj, value)\r
- def __delete__(self, obj):\r
- return self.__delete(obj)\r
- def __init__(self):\r
- self.__x = 0\r
- def __get_x(self):\r
- x = self.__x\r
- self.__x = x+1\r
- return x\r
- def __set_x(self, x):\r
- self.__x = x\r
- def __delete_x(self):\r
- del self.__x\r
- x = computed_attribute(__get_x, __set_x, __delete_x)\r
- a = C()\r
- self.assertEqual(a.x, 0)\r
- self.assertEqual(a.x, 1)\r
- a.x = 10\r
- self.assertEqual(a.x, 10)\r
- self.assertEqual(a.x, 11)\r
- del a.x\r
- self.assertEqual(hasattr(a, 'x'), 0)\r
-\r
- def test_newslots(self):\r
- # Testing __new__ slot override...\r
- class C(list):\r
- def __new__(cls):\r
- self = list.__new__(cls)\r
- self.foo = 1\r
- return self\r
- def __init__(self):\r
- self.foo = self.foo + 2\r
- a = C()\r
- self.assertEqual(a.foo, 3)\r
- self.assertEqual(a.__class__, C)\r
- class D(C):\r
- pass\r
- b = D()\r
- self.assertEqual(b.foo, 3)\r
- self.assertEqual(b.__class__, D)\r
-\r
- def test_altmro(self):\r
- # Testing mro() and overriding it...\r
- class A(object):\r
- def f(self): return "A"\r
- class B(A):\r
- pass\r
- class C(A):\r
- def f(self): return "C"\r
- class D(B, C):\r
- pass\r
- self.assertEqual(D.mro(), [D, B, C, A, object])\r
- self.assertEqual(D.__mro__, (D, B, C, A, object))\r
- self.assertEqual(D().f(), "C")\r
-\r
- class PerverseMetaType(type):\r
- def mro(cls):\r
- L = type.mro(cls)\r
- L.reverse()\r
- return L\r
- class X(D,B,C,A):\r
- __metaclass__ = PerverseMetaType\r
- self.assertEqual(X.__mro__, (object, A, C, B, D, X))\r
- self.assertEqual(X().f(), "A")\r
-\r
- try:\r
- class X(object):\r
- class __metaclass__(type):\r
- def mro(self):\r
- return [self, dict, object]\r
- # In CPython, the class creation above already raises\r
- # TypeError, as a protection against the fact that\r
- # instances of X would segfault it. In other Python\r
- # implementations it would be ok to let the class X\r
- # be created, but instead get a clean TypeError on the\r
- # __setitem__ below.\r
- x = object.__new__(X)\r
- x[5] = 6\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("devious mro() return not caught")\r
-\r
- try:\r
- class X(object):\r
- class __metaclass__(type):\r
- def mro(self):\r
- return [1]\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("non-class mro() return not caught")\r
-\r
- try:\r
- class X(object):\r
- class __metaclass__(type):\r
- def mro(self):\r
- return 1\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("non-sequence mro() return not caught")\r
-\r
- def test_overloading(self):\r
- # Testing operator overloading...\r
-\r
- class B(object):\r
- "Intermediate class because object doesn't have a __setattr__"\r
-\r
- class C(B):\r
- def __getattr__(self, name):\r
- if name == "foo":\r
- return ("getattr", name)\r
- else:\r
- raise AttributeError\r
- def __setattr__(self, name, value):\r
- if name == "foo":\r
- self.setattr = (name, value)\r
- else:\r
- return B.__setattr__(self, name, value)\r
- def __delattr__(self, name):\r
- if name == "foo":\r
- self.delattr = name\r
- else:\r
- return B.__delattr__(self, name)\r
-\r
- def __getitem__(self, key):\r
- return ("getitem", key)\r
- def __setitem__(self, key, value):\r
- self.setitem = (key, value)\r
- def __delitem__(self, key):\r
- self.delitem = key\r
-\r
- def __getslice__(self, i, j):\r
- return ("getslice", i, j)\r
- def __setslice__(self, i, j, value):\r
- self.setslice = (i, j, value)\r
- def __delslice__(self, i, j):\r
- self.delslice = (i, j)\r
-\r
- a = C()\r
- self.assertEqual(a.foo, ("getattr", "foo"))\r
- a.foo = 12\r
- self.assertEqual(a.setattr, ("foo", 12))\r
- del a.foo\r
- self.assertEqual(a.delattr, "foo")\r
-\r
- self.assertEqual(a[12], ("getitem", 12))\r
- a[12] = 21\r
- self.assertEqual(a.setitem, (12, 21))\r
- del a[12]\r
- self.assertEqual(a.delitem, 12)\r
-\r
- self.assertEqual(a[0:10], ("getslice", 0, 10))\r
- a[0:10] = "foo"\r
- self.assertEqual(a.setslice, (0, 10, "foo"))\r
- del a[0:10]\r
- self.assertEqual(a.delslice, (0, 10))\r
-\r
- def test_methods(self):\r
- # Testing methods...\r
- class C(object):\r
- def __init__(self, x):\r
- self.x = x\r
- def foo(self):\r
- return self.x\r
- c1 = C(1)\r
- self.assertEqual(c1.foo(), 1)\r
- class D(C):\r
- boo = C.foo\r
- goo = c1.foo\r
- d2 = D(2)\r
- self.assertEqual(d2.foo(), 2)\r
- self.assertEqual(d2.boo(), 2)\r
- self.assertEqual(d2.goo(), 1)\r
- class E(object):\r
- foo = C.foo\r
- self.assertEqual(E().foo, C.foo) # i.e., unbound\r
- self.assertTrue(repr(C.foo.__get__(C(1))).startswith("<bound method "))\r
-\r
- def test_special_method_lookup(self):\r
- # The lookup of special methods bypasses __getattr__ and\r
- # __getattribute__, but they still can be descriptors.\r
-\r
- def run_context(manager):\r
- with manager:\r
- pass\r
- def iden(self):\r
- return self\r
- def hello(self):\r
- return "hello"\r
- def empty_seq(self):\r
- return []\r
- def zero(self):\r
- return 0\r
- def complex_num(self):\r
- return 1j\r
- def stop(self):\r
- raise StopIteration\r
- def return_true(self, thing=None):\r
- return True\r
- def do_isinstance(obj):\r
- return isinstance(int, obj)\r
- def do_issubclass(obj):\r
- return issubclass(int, obj)\r
- def swallow(*args):\r
- pass\r
- def do_dict_missing(checker):\r
- class DictSub(checker.__class__, dict):\r
- pass\r
- self.assertEqual(DictSub()["hi"], 4)\r
- def some_number(self_, key):\r
- self.assertEqual(key, "hi")\r
- return 4\r
- def format_impl(self, spec):\r
- return "hello"\r
-\r
- # It would be nice to have every special method tested here, but I'm\r
- # only listing the ones I can remember outside of typeobject.c, since it\r
- # does it right.\r
- specials = [\r
- ("__unicode__", unicode, hello, set(), {}),\r
- ("__reversed__", reversed, empty_seq, set(), {}),\r
- ("__length_hint__", list, zero, set(),\r
- {"__iter__" : iden, "next" : stop}),\r
- ("__sizeof__", sys.getsizeof, zero, set(), {}),\r
- ("__instancecheck__", do_isinstance, return_true, set(), {}),\r
- ("__missing__", do_dict_missing, some_number,\r
- set(("__class__",)), {}),\r
- ("__subclasscheck__", do_issubclass, return_true,\r
- set(("__bases__",)), {}),\r
- ("__enter__", run_context, iden, set(), {"__exit__" : swallow}),\r
- ("__exit__", run_context, swallow, set(), {"__enter__" : iden}),\r
- ("__complex__", complex, complex_num, set(), {}),\r
- ("__format__", format, format_impl, set(), {}),\r
- ("__dir__", dir, empty_seq, set(), {}),\r
- ]\r
-\r
- class Checker(object):\r
- def __getattr__(self, attr, test=self):\r
- test.fail("__getattr__ called with {0}".format(attr))\r
- def __getattribute__(self, attr, test=self):\r
- if attr not in ok:\r
- test.fail("__getattribute__ called with {0}".format(attr))\r
- return object.__getattribute__(self, attr)\r
- class SpecialDescr(object):\r
- def __init__(self, impl):\r
- self.impl = impl\r
- def __get__(self, obj, owner):\r
- record.append(1)\r
- return self.impl.__get__(obj, owner)\r
- class MyException(Exception):\r
- pass\r
- class ErrDescr(object):\r
- def __get__(self, obj, owner):\r
- raise MyException\r
-\r
- for name, runner, meth_impl, ok, env in specials:\r
- class X(Checker):\r
- pass\r
- for attr, obj in env.iteritems():\r
- setattr(X, attr, obj)\r
- setattr(X, name, meth_impl)\r
- runner(X())\r
-\r
- record = []\r
- class X(Checker):\r
- pass\r
- for attr, obj in env.iteritems():\r
- setattr(X, attr, obj)\r
- setattr(X, name, SpecialDescr(meth_impl))\r
- runner(X())\r
- self.assertEqual(record, [1], name)\r
-\r
- class X(Checker):\r
- pass\r
- for attr, obj in env.iteritems():\r
- setattr(X, attr, obj)\r
- setattr(X, name, ErrDescr())\r
- try:\r
- runner(X())\r
- except MyException:\r
- pass\r
- else:\r
- self.fail("{0!r} didn't raise".format(name))\r
-\r
- def test_specials(self):\r
- # Testing special operators...\r
- # Test operators like __hash__ for which a built-in default exists\r
-\r
- # Test the default behavior for static classes\r
- class C(object):\r
- def __getitem__(self, i):\r
- if 0 <= i < 10: return i\r
- raise IndexError\r
- c1 = C()\r
- c2 = C()\r
- self.assertTrue(not not c1) # What?\r
- self.assertNotEqual(id(c1), id(c2))\r
- hash(c1)\r
- hash(c2)\r
- self.assertEqual(cmp(c1, c2), cmp(id(c1), id(c2)))\r
- self.assertEqual(c1, c1)\r
- self.assertTrue(c1 != c2)\r
- self.assertTrue(not c1 != c1)\r
- self.assertTrue(not c1 == c2)\r
- # Note that the module name appears in str/repr, and that varies\r
- # depending on whether this test is run standalone or from a framework.\r
- self.assertTrue(str(c1).find('C object at ') >= 0)\r
- self.assertEqual(str(c1), repr(c1))\r
- self.assertNotIn(-1, c1)\r
- for i in range(10):\r
- self.assertIn(i, c1)\r
- self.assertNotIn(10, c1)\r
- # Test the default behavior for dynamic classes\r
- class D(object):\r
- def __getitem__(self, i):\r
- if 0 <= i < 10: return i\r
- raise IndexError\r
- d1 = D()\r
- d2 = D()\r
- self.assertTrue(not not d1)\r
- self.assertNotEqual(id(d1), id(d2))\r
- hash(d1)\r
- hash(d2)\r
- self.assertEqual(cmp(d1, d2), cmp(id(d1), id(d2)))\r
- self.assertEqual(d1, d1)\r
- self.assertNotEqual(d1, d2)\r
- self.assertTrue(not d1 != d1)\r
- self.assertTrue(not d1 == d2)\r
- # Note that the module name appears in str/repr, and that varies\r
- # depending on whether this test is run standalone or from a framework.\r
- self.assertTrue(str(d1).find('D object at ') >= 0)\r
- self.assertEqual(str(d1), repr(d1))\r
- self.assertNotIn(-1, d1)\r
- for i in range(10):\r
- self.assertIn(i, d1)\r
- self.assertNotIn(10, d1)\r
- # Test overridden behavior for static classes\r
- class Proxy(object):\r
- def __init__(self, x):\r
- self.x = x\r
- def __nonzero__(self):\r
- return not not self.x\r
- def __hash__(self):\r
- return hash(self.x)\r
- def __eq__(self, other):\r
- return self.x == other\r
- def __ne__(self, other):\r
- return self.x != other\r
- def __cmp__(self, other):\r
- return cmp(self.x, other.x)\r
- def __str__(self):\r
- return "Proxy:%s" % self.x\r
- def __repr__(self):\r
- return "Proxy(%r)" % self.x\r
- def __contains__(self, value):\r
- return value in self.x\r
- p0 = Proxy(0)\r
- p1 = Proxy(1)\r
- p_1 = Proxy(-1)\r
- self.assertFalse(p0)\r
- self.assertTrue(not not p1)\r
- self.assertEqual(hash(p0), hash(0))\r
- self.assertEqual(p0, p0)\r
- self.assertNotEqual(p0, p1)\r
- self.assertTrue(not p0 != p0)\r
- self.assertEqual(not p0, p1)\r
- self.assertEqual(cmp(p0, p1), -1)\r
- self.assertEqual(cmp(p0, p0), 0)\r
- self.assertEqual(cmp(p0, p_1), 1)\r
- self.assertEqual(str(p0), "Proxy:0")\r
- self.assertEqual(repr(p0), "Proxy(0)")\r
- p10 = Proxy(range(10))\r
- self.assertNotIn(-1, p10)\r
- for i in range(10):\r
- self.assertIn(i, p10)\r
- self.assertNotIn(10, p10)\r
- # Test overridden behavior for dynamic classes\r
- class DProxy(object):\r
- def __init__(self, x):\r
- self.x = x\r
- def __nonzero__(self):\r
- return not not self.x\r
- def __hash__(self):\r
- return hash(self.x)\r
- def __eq__(self, other):\r
- return self.x == other\r
- def __ne__(self, other):\r
- return self.x != other\r
- def __cmp__(self, other):\r
- return cmp(self.x, other.x)\r
- def __str__(self):\r
- return "DProxy:%s" % self.x\r
- def __repr__(self):\r
- return "DProxy(%r)" % self.x\r
- def __contains__(self, value):\r
- return value in self.x\r
- p0 = DProxy(0)\r
- p1 = DProxy(1)\r
- p_1 = DProxy(-1)\r
- self.assertFalse(p0)\r
- self.assertTrue(not not p1)\r
- self.assertEqual(hash(p0), hash(0))\r
- self.assertEqual(p0, p0)\r
- self.assertNotEqual(p0, p1)\r
- self.assertNotEqual(not p0, p0)\r
- self.assertEqual(not p0, p1)\r
- self.assertEqual(cmp(p0, p1), -1)\r
- self.assertEqual(cmp(p0, p0), 0)\r
- self.assertEqual(cmp(p0, p_1), 1)\r
- self.assertEqual(str(p0), "DProxy:0")\r
- self.assertEqual(repr(p0), "DProxy(0)")\r
- p10 = DProxy(range(10))\r
- self.assertNotIn(-1, p10)\r
- for i in range(10):\r
- self.assertIn(i, p10)\r
- self.assertNotIn(10, p10)\r
-\r
- # Safety test for __cmp__\r
- def unsafecmp(a, b):\r
- if not hasattr(a, '__cmp__'):\r
- return # some types don't have a __cmp__ any more (so the\r
- # test doesn't make sense any more), or maybe they\r
- # never had a __cmp__ at all, e.g. in PyPy\r
- try:\r
- a.__class__.__cmp__(a, b)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't allow %s.__cmp__(%r, %r)" % (\r
- a.__class__, a, b))\r
-\r
- unsafecmp(u"123", "123")\r
- unsafecmp("123", u"123")\r
- unsafecmp(1, 1.0)\r
- unsafecmp(1.0, 1)\r
- unsafecmp(1, 1L)\r
- unsafecmp(1L, 1)\r
-\r
- @test_support.impl_detail("custom logic for printing to real file objects")\r
- def test_recursions_1(self):\r
- # Testing recursion checks ...\r
- class Letter(str):\r
- def __new__(cls, letter):\r
- if letter == 'EPS':\r
- return str.__new__(cls)\r
- return str.__new__(cls, letter)\r
- def __str__(self):\r
- if not self:\r
- return 'EPS'\r
- return self\r
- # sys.stdout needs to be the original to trigger the recursion bug\r
- test_stdout = sys.stdout\r
- sys.stdout = test_support.get_original_stdout()\r
- try:\r
- # nothing should actually be printed, this should raise an exception\r
- print Letter('w')\r
- except RuntimeError:\r
- pass\r
- else:\r
- self.fail("expected a RuntimeError for print recursion")\r
- finally:\r
- sys.stdout = test_stdout\r
-\r
- def test_recursions_2(self):\r
- # Bug #1202533.\r
- class A(object):\r
- pass\r
- A.__mul__ = types.MethodType(lambda self, x: self * x, None, A)\r
- try:\r
- A()*2\r
- except RuntimeError:\r
- pass\r
- else:\r
- self.fail("expected a RuntimeError")\r
-\r
- def test_weakrefs(self):\r
- # Testing weak references...\r
- import weakref\r
- class C(object):\r
- pass\r
- c = C()\r
- r = weakref.ref(c)\r
- self.assertEqual(r(), c)\r
- del c\r
- test_support.gc_collect()\r
- self.assertEqual(r(), None)\r
- del r\r
- class NoWeak(object):\r
- __slots__ = ['foo']\r
- no = NoWeak()\r
- try:\r
- weakref.ref(no)\r
- except TypeError, msg:\r
- self.assertTrue(str(msg).find("weak reference") >= 0)\r
- else:\r
- self.fail("weakref.ref(no) should be illegal")\r
- class Weak(object):\r
- __slots__ = ['foo', '__weakref__']\r
- yes = Weak()\r
- r = weakref.ref(yes)\r
- self.assertEqual(r(), yes)\r
- del yes\r
- test_support.gc_collect()\r
- self.assertEqual(r(), None)\r
- del r\r
-\r
- def test_properties(self):\r
- # Testing property...\r
- class C(object):\r
- def getx(self):\r
- return self.__x\r
- def setx(self, value):\r
- self.__x = value\r
- def delx(self):\r
- del self.__x\r
- x = property(getx, setx, delx, doc="I'm the x property.")\r
- a = C()\r
- self.assertFalse(hasattr(a, "x"))\r
- a.x = 42\r
- self.assertEqual(a._C__x, 42)\r
- self.assertEqual(a.x, 42)\r
- del a.x\r
- self.assertFalse(hasattr(a, "x"))\r
- self.assertFalse(hasattr(a, "_C__x"))\r
- C.x.__set__(a, 100)\r
- self.assertEqual(C.x.__get__(a), 100)\r
- C.x.__delete__(a)\r
- self.assertFalse(hasattr(a, "x"))\r
-\r
- raw = C.__dict__['x']\r
- self.assertIsInstance(raw, property)\r
-\r
- attrs = dir(raw)\r
- self.assertIn("__doc__", attrs)\r
- self.assertIn("fget", attrs)\r
- self.assertIn("fset", attrs)\r
- self.assertIn("fdel", attrs)\r
-\r
- self.assertEqual(raw.__doc__, "I'm the x property.")\r
- self.assertTrue(raw.fget is C.__dict__['getx'])\r
- self.assertTrue(raw.fset is C.__dict__['setx'])\r
- self.assertTrue(raw.fdel is C.__dict__['delx'])\r
-\r
- for attr in "__doc__", "fget", "fset", "fdel":\r
- try:\r
- setattr(raw, attr, 42)\r
- except TypeError, msg:\r
- if str(msg).find('readonly') < 0:\r
- self.fail("when setting readonly attr %r on a property, "\r
- "got unexpected TypeError msg %r" % (attr, str(msg)))\r
- else:\r
- self.fail("expected TypeError from trying to set readonly %r "\r
- "attr on a property" % attr)\r
-\r
- class D(object):\r
- __getitem__ = property(lambda s: 1/0)\r
-\r
- d = D()\r
- try:\r
- for i in d:\r
- str(i)\r
- except ZeroDivisionError:\r
- pass\r
- else:\r
- self.fail("expected ZeroDivisionError from bad property")\r
-\r
- @unittest.skipIf(sys.flags.optimize >= 2,\r
- "Docstrings are omitted with -O2 and above")\r
- def test_properties_doc_attrib(self):\r
- class E(object):\r
- def getter(self):\r
- "getter method"\r
- return 0\r
- def setter(self_, value):\r
- "setter method"\r
- pass\r
- prop = property(getter)\r
- self.assertEqual(prop.__doc__, "getter method")\r
- prop2 = property(fset=setter)\r
- self.assertEqual(prop2.__doc__, None)\r
-\r
- def test_testcapi_no_segfault(self):\r
- # this segfaulted in 2.5b2\r
- try:\r
- import _testcapi\r
- except ImportError:\r
- pass\r
- else:\r
- class X(object):\r
- p = property(_testcapi.test_with_docstring)\r
-\r
- def test_properties_plus(self):\r
- class C(object):\r
- foo = property(doc="hello")\r
- @foo.getter\r
- def foo(self):\r
- return self._foo\r
- @foo.setter\r
- def foo(self, value):\r
- self._foo = abs(value)\r
- @foo.deleter\r
- def foo(self):\r
- del self._foo\r
- c = C()\r
- self.assertEqual(C.foo.__doc__, "hello")\r
- self.assertFalse(hasattr(c, "foo"))\r
- c.foo = -42\r
- self.assertTrue(hasattr(c, '_foo'))\r
- self.assertEqual(c._foo, 42)\r
- self.assertEqual(c.foo, 42)\r
- del c.foo\r
- self.assertFalse(hasattr(c, '_foo'))\r
- self.assertFalse(hasattr(c, "foo"))\r
-\r
- class D(C):\r
- @C.foo.deleter\r
- def foo(self):\r
- try:\r
- del self._foo\r
- except AttributeError:\r
- pass\r
- d = D()\r
- d.foo = 24\r
- self.assertEqual(d.foo, 24)\r
- del d.foo\r
- del d.foo\r
-\r
- class E(object):\r
- @property\r
- def foo(self):\r
- return self._foo\r
- @foo.setter\r
- def foo(self, value):\r
- raise RuntimeError\r
- @foo.setter\r
- def foo(self, value):\r
- self._foo = abs(value)\r
- @foo.deleter\r
- def foo(self, value=None):\r
- del self._foo\r
-\r
- e = E()\r
- e.foo = -42\r
- self.assertEqual(e.foo, 42)\r
- del e.foo\r
-\r
- class F(E):\r
- @E.foo.deleter\r
- def foo(self):\r
- del self._foo\r
- @foo.setter\r
- def foo(self, value):\r
- self._foo = max(0, value)\r
- f = F()\r
- f.foo = -10\r
- self.assertEqual(f.foo, 0)\r
- del f.foo\r
-\r
- def test_dict_constructors(self):\r
- # Testing dict constructor ...\r
- d = dict()\r
- self.assertEqual(d, {})\r
- d = dict({})\r
- self.assertEqual(d, {})\r
- d = dict({1: 2, 'a': 'b'})\r
- self.assertEqual(d, {1: 2, 'a': 'b'})\r
- self.assertEqual(d, dict(d.items()))\r
- self.assertEqual(d, dict(d.iteritems()))\r
- d = dict({'one':1, 'two':2})\r
- self.assertEqual(d, dict(one=1, two=2))\r
- self.assertEqual(d, dict(**d))\r
- self.assertEqual(d, dict({"one": 1}, two=2))\r
- self.assertEqual(d, dict([("two", 2)], one=1))\r
- self.assertEqual(d, dict([("one", 100), ("two", 200)], **d))\r
- self.assertEqual(d, dict(**d))\r
-\r
- for badarg in 0, 0L, 0j, "0", [0], (0,):\r
- try:\r
- dict(badarg)\r
- except TypeError:\r
- pass\r
- except ValueError:\r
- if badarg == "0":\r
- # It's a sequence, and its elements are also sequences (gotta\r
- # love strings <wink>), but they aren't of length 2, so this\r
- # one seemed better as a ValueError than a TypeError.\r
- pass\r
- else:\r
- self.fail("no TypeError from dict(%r)" % badarg)\r
- else:\r
- self.fail("no TypeError from dict(%r)" % badarg)\r
-\r
- try:\r
- dict({}, {})\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("no TypeError from dict({}, {})")\r
-\r
- class Mapping:\r
- # Lacks a .keys() method; will be added later.\r
- dict = {1:2, 3:4, 'a':1j}\r
-\r
- try:\r
- dict(Mapping())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("no TypeError from dict(incomplete mapping)")\r
-\r
- Mapping.keys = lambda self: self.dict.keys()\r
- Mapping.__getitem__ = lambda self, i: self.dict[i]\r
- d = dict(Mapping())\r
- self.assertEqual(d, Mapping.dict)\r
-\r
- # Init from sequence of iterable objects, each producing a 2-sequence.\r
- class AddressBookEntry:\r
- def __init__(self, first, last):\r
- self.first = first\r
- self.last = last\r
- def __iter__(self):\r
- return iter([self.first, self.last])\r
-\r
- d = dict([AddressBookEntry('Tim', 'Warsaw'),\r
- AddressBookEntry('Barry', 'Peters'),\r
- AddressBookEntry('Tim', 'Peters'),\r
- AddressBookEntry('Barry', 'Warsaw')])\r
- self.assertEqual(d, {'Barry': 'Warsaw', 'Tim': 'Peters'})\r
-\r
- d = dict(zip(range(4), range(1, 5)))\r
- self.assertEqual(d, dict([(i, i+1) for i in range(4)]))\r
-\r
- # Bad sequence lengths.\r
- for bad in [('tooshort',)], [('too', 'long', 'by 1')]:\r
- try:\r
- dict(bad)\r
- except ValueError:\r
- pass\r
- else:\r
- self.fail("no ValueError from dict(%r)" % bad)\r
-\r
- def test_dir(self):\r
- # Testing dir() ...\r
- junk = 12\r
- self.assertEqual(dir(), ['junk', 'self'])\r
- del junk\r
-\r
- # Just make sure these don't blow up!\r
- for arg in 2, 2L, 2j, 2e0, [2], "2", u"2", (2,), {2:2}, type, self.test_dir:\r
- dir(arg)\r
-\r
- # Try classic classes.\r
- class C:\r
- Cdata = 1\r
- def Cmethod(self): pass\r
-\r
- cstuff = ['Cdata', 'Cmethod', '__doc__', '__module__']\r
- self.assertEqual(dir(C), cstuff)\r
- self.assertIn('im_self', dir(C.Cmethod))\r
-\r
- c = C() # c.__doc__ is an odd thing to see here; ditto c.__module__.\r
- self.assertEqual(dir(c), cstuff)\r
-\r
- c.cdata = 2\r
- c.cmethod = lambda self: 0\r
- self.assertEqual(dir(c), cstuff + ['cdata', 'cmethod'])\r
- self.assertIn('im_self', dir(c.Cmethod))\r
-\r
- class A(C):\r
- Adata = 1\r
- def Amethod(self): pass\r
-\r
- astuff = ['Adata', 'Amethod'] + cstuff\r
- self.assertEqual(dir(A), astuff)\r
- self.assertIn('im_self', dir(A.Amethod))\r
- a = A()\r
- self.assertEqual(dir(a), astuff)\r
- self.assertIn('im_self', dir(a.Amethod))\r
- a.adata = 42\r
- a.amethod = lambda self: 3\r
- self.assertEqual(dir(a), astuff + ['adata', 'amethod'])\r
-\r
- # The same, but with new-style classes. Since these have object as a\r
- # base class, a lot more gets sucked in.\r
- def interesting(strings):\r
- return [s for s in strings if not s.startswith('_')]\r
-\r
- class C(object):\r
- Cdata = 1\r
- def Cmethod(self): pass\r
-\r
- cstuff = ['Cdata', 'Cmethod']\r
- self.assertEqual(interesting(dir(C)), cstuff)\r
-\r
- c = C()\r
- self.assertEqual(interesting(dir(c)), cstuff)\r
- self.assertIn('im_self', dir(C.Cmethod))\r
-\r
- c.cdata = 2\r
- c.cmethod = lambda self: 0\r
- self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])\r
- self.assertIn('im_self', dir(c.Cmethod))\r
-\r
- class A(C):\r
- Adata = 1\r
- def Amethod(self): pass\r
-\r
- astuff = ['Adata', 'Amethod'] + cstuff\r
- self.assertEqual(interesting(dir(A)), astuff)\r
- self.assertIn('im_self', dir(A.Amethod))\r
- a = A()\r
- self.assertEqual(interesting(dir(a)), astuff)\r
- a.adata = 42\r
- a.amethod = lambda self: 3\r
- self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod'])\r
- self.assertIn('im_self', dir(a.Amethod))\r
-\r
- # Try a module subclass.\r
- class M(type(sys)):\r
- pass\r
- minstance = M("m")\r
- minstance.b = 2\r
- minstance.a = 1\r
- names = [x for x in dir(minstance) if x not in ["__name__", "__doc__"]]\r
- self.assertEqual(names, ['a', 'b'])\r
-\r
- class M2(M):\r
- def getdict(self):\r
- return "Not a dict!"\r
- __dict__ = property(getdict)\r
-\r
- m2instance = M2("m2")\r
- m2instance.b = 2\r
- m2instance.a = 1\r
- self.assertEqual(m2instance.__dict__, "Not a dict!")\r
- try:\r
- dir(m2instance)\r
- except TypeError:\r
- pass\r
-\r
- # Two essentially featureless objects, just inheriting stuff from\r
- # object.\r
- self.assertEqual(dir(NotImplemented), dir(Ellipsis))\r
- if test_support.check_impl_detail():\r
- # None differs in PyPy: it has a __nonzero__\r
- self.assertEqual(dir(None), dir(Ellipsis))\r
-\r
- # Nasty test case for proxied objects\r
- class Wrapper(object):\r
- def __init__(self, obj):\r
- self.__obj = obj\r
- def __repr__(self):\r
- return "Wrapper(%s)" % repr(self.__obj)\r
- def __getitem__(self, key):\r
- return Wrapper(self.__obj[key])\r
- def __len__(self):\r
- return len(self.__obj)\r
- def __getattr__(self, name):\r
- return Wrapper(getattr(self.__obj, name))\r
-\r
- class C(object):\r
- def __getclass(self):\r
- return Wrapper(type(self))\r
- __class__ = property(__getclass)\r
-\r
- dir(C()) # This used to segfault\r
-\r
- def test_supers(self):\r
- # Testing super...\r
-\r
- class A(object):\r
- def meth(self, a):\r
- return "A(%r)" % a\r
-\r
- self.assertEqual(A().meth(1), "A(1)")\r
-\r
- class B(A):\r
- def __init__(self):\r
- self.__super = super(B, self)\r
- def meth(self, a):\r
- return "B(%r)" % a + self.__super.meth(a)\r
-\r
- self.assertEqual(B().meth(2), "B(2)A(2)")\r
-\r
- class C(A):\r
- def meth(self, a):\r
- return "C(%r)" % a + self.__super.meth(a)\r
- C._C__super = super(C)\r
-\r
- self.assertEqual(C().meth(3), "C(3)A(3)")\r
-\r
- class D(C, B):\r
- def meth(self, a):\r
- return "D(%r)" % a + super(D, self).meth(a)\r
-\r
- self.assertEqual(D().meth(4), "D(4)C(4)B(4)A(4)")\r
-\r
- # Test for subclassing super\r
-\r
- class mysuper(super):\r
- def __init__(self, *args):\r
- return super(mysuper, self).__init__(*args)\r
-\r
- class E(D):\r
- def meth(self, a):\r
- return "E(%r)" % a + mysuper(E, self).meth(a)\r
-\r
- self.assertEqual(E().meth(5), "E(5)D(5)C(5)B(5)A(5)")\r
-\r
- class F(E):\r
- def meth(self, a):\r
- s = self.__super # == mysuper(F, self)\r
- return "F(%r)[%s]" % (a, s.__class__.__name__) + s.meth(a)\r
- F._F__super = mysuper(F)\r
-\r
- self.assertEqual(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)")\r
-\r
- # Make sure certain errors are raised\r
-\r
- try:\r
- super(D, 42)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't allow super(D, 42)")\r
-\r
- try:\r
- super(D, C())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't allow super(D, C())")\r
-\r
- try:\r
- super(D).__get__(12)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't allow super(D).__get__(12)")\r
-\r
- try:\r
- super(D).__get__(C())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't allow super(D).__get__(C())")\r
-\r
- # Make sure data descriptors can be overridden and accessed via super\r
- # (new feature in Python 2.3)\r
-\r
- class DDbase(object):\r
- def getx(self): return 42\r
- x = property(getx)\r
-\r
- class DDsub(DDbase):\r
- def getx(self): return "hello"\r
- x = property(getx)\r
-\r
- dd = DDsub()\r
- self.assertEqual(dd.x, "hello")\r
- self.assertEqual(super(DDsub, dd).x, 42)\r
-\r
- # Ensure that super() lookup of descriptor from classmethod\r
- # works (SF ID# 743627)\r
-\r
- class Base(object):\r
- aProp = property(lambda self: "foo")\r
-\r
- class Sub(Base):\r
- @classmethod\r
- def test(klass):\r
- return super(Sub,klass).aProp\r
-\r
- self.assertEqual(Sub.test(), Base.aProp)\r
-\r
- # Verify that super() doesn't allow keyword args\r
- try:\r
- super(Base, kw=1)\r
- except TypeError:\r
- pass\r
- else:\r
- self.assertEqual("super shouldn't accept keyword args")\r
-\r
- def test_basic_inheritance(self):\r
- # Testing inheritance from basic types...\r
-\r
- class hexint(int):\r
- def __repr__(self):\r
- return hex(self)\r
- def __add__(self, other):\r
- return hexint(int.__add__(self, other))\r
- # (Note that overriding __radd__ doesn't work,\r
- # because the int type gets first dibs.)\r
- self.assertEqual(repr(hexint(7) + 9), "0x10")\r
- self.assertEqual(repr(hexint(1000) + 7), "0x3ef")\r
- a = hexint(12345)\r
- self.assertEqual(a, 12345)\r
- self.assertEqual(int(a), 12345)\r
- self.assertTrue(int(a).__class__ is int)\r
- self.assertEqual(hash(a), hash(12345))\r
- self.assertTrue((+a).__class__ is int)\r
- self.assertTrue((a >> 0).__class__ is int)\r
- self.assertTrue((a << 0).__class__ is int)\r
- self.assertTrue((hexint(0) << 12).__class__ is int)\r
- self.assertTrue((hexint(0) >> 12).__class__ is int)\r
-\r
- class octlong(long):\r
- __slots__ = []\r
- def __str__(self):\r
- s = oct(self)\r
- if s[-1] == 'L':\r
- s = s[:-1]\r
- return s\r
- def __add__(self, other):\r
- return self.__class__(super(octlong, self).__add__(other))\r
- __radd__ = __add__\r
- self.assertEqual(str(octlong(3) + 5), "010")\r
- # (Note that overriding __radd__ here only seems to work\r
- # because the example uses a short int left argument.)\r
- self.assertEqual(str(5 + octlong(3000)), "05675")\r
- a = octlong(12345)\r
- self.assertEqual(a, 12345L)\r
- self.assertEqual(long(a), 12345L)\r
- self.assertEqual(hash(a), hash(12345L))\r
- self.assertTrue(long(a).__class__ is long)\r
- self.assertTrue((+a).__class__ is long)\r
- self.assertTrue((-a).__class__ is long)\r
- self.assertTrue((-octlong(0)).__class__ is long)\r
- self.assertTrue((a >> 0).__class__ is long)\r
- self.assertTrue((a << 0).__class__ is long)\r
- self.assertTrue((a - 0).__class__ is long)\r
- self.assertTrue((a * 1).__class__ is long)\r
- self.assertTrue((a ** 1).__class__ is long)\r
- self.assertTrue((a // 1).__class__ is long)\r
- self.assertTrue((1 * a).__class__ is long)\r
- self.assertTrue((a | 0).__class__ is long)\r
- self.assertTrue((a ^ 0).__class__ is long)\r
- self.assertTrue((a & -1L).__class__ is long)\r
- self.assertTrue((octlong(0) << 12).__class__ is long)\r
- self.assertTrue((octlong(0) >> 12).__class__ is long)\r
- self.assertTrue(abs(octlong(0)).__class__ is long)\r
-\r
- # Because octlong overrides __add__, we can't check the absence of +0\r
- # optimizations using octlong.\r
- class longclone(long):\r
- pass\r
- a = longclone(1)\r
- self.assertTrue((a + 0).__class__ is long)\r
- self.assertTrue((0 + a).__class__ is long)\r
-\r
- # Check that negative clones don't segfault\r
- a = longclone(-1)\r
- self.assertEqual(a.__dict__, {})\r
- self.assertEqual(long(a), -1) # self.assertTrue PyNumber_Long() copies the sign bit\r
-\r
- class precfloat(float):\r
- __slots__ = ['prec']\r
- def __init__(self, value=0.0, prec=12):\r
- self.prec = int(prec)\r
- def __repr__(self):\r
- return "%.*g" % (self.prec, self)\r
- self.assertEqual(repr(precfloat(1.1)), "1.1")\r
- a = precfloat(12345)\r
- self.assertEqual(a, 12345.0)\r
- self.assertEqual(float(a), 12345.0)\r
- self.assertTrue(float(a).__class__ is float)\r
- self.assertEqual(hash(a), hash(12345.0))\r
- self.assertTrue((+a).__class__ is float)\r
-\r
- class madcomplex(complex):\r
- def __repr__(self):\r
- return "%.17gj%+.17g" % (self.imag, self.real)\r
- a = madcomplex(-3, 4)\r
- self.assertEqual(repr(a), "4j-3")\r
- base = complex(-3, 4)\r
- self.assertEqual(base.__class__, complex)\r
- self.assertEqual(a, base)\r
- self.assertEqual(complex(a), base)\r
- self.assertEqual(complex(a).__class__, complex)\r
- a = madcomplex(a) # just trying another form of the constructor\r
- self.assertEqual(repr(a), "4j-3")\r
- self.assertEqual(a, base)\r
- self.assertEqual(complex(a), base)\r
- self.assertEqual(complex(a).__class__, complex)\r
- self.assertEqual(hash(a), hash(base))\r
- self.assertEqual((+a).__class__, complex)\r
- self.assertEqual((a + 0).__class__, complex)\r
- self.assertEqual(a + 0, base)\r
- self.assertEqual((a - 0).__class__, complex)\r
- self.assertEqual(a - 0, base)\r
- self.assertEqual((a * 1).__class__, complex)\r
- self.assertEqual(a * 1, base)\r
- self.assertEqual((a / 1).__class__, complex)\r
- self.assertEqual(a / 1, base)\r
-\r
- class madtuple(tuple):\r
- _rev = None\r
- def rev(self):\r
- if self._rev is not None:\r
- return self._rev\r
- L = list(self)\r
- L.reverse()\r
- self._rev = self.__class__(L)\r
- return self._rev\r
- a = madtuple((1,2,3,4,5,6,7,8,9,0))\r
- self.assertEqual(a, (1,2,3,4,5,6,7,8,9,0))\r
- self.assertEqual(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1)))\r
- self.assertEqual(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0)))\r
- for i in range(512):\r
- t = madtuple(range(i))\r
- u = t.rev()\r
- v = u.rev()\r
- self.assertEqual(v, t)\r
- a = madtuple((1,2,3,4,5))\r
- self.assertEqual(tuple(a), (1,2,3,4,5))\r
- self.assertTrue(tuple(a).__class__ is tuple)\r
- self.assertEqual(hash(a), hash((1,2,3,4,5)))\r
- self.assertTrue(a[:].__class__ is tuple)\r
- self.assertTrue((a * 1).__class__ is tuple)\r
- self.assertTrue((a * 0).__class__ is tuple)\r
- self.assertTrue((a + ()).__class__ is tuple)\r
- a = madtuple(())\r
- self.assertEqual(tuple(a), ())\r
- self.assertTrue(tuple(a).__class__ is tuple)\r
- self.assertTrue((a + a).__class__ is tuple)\r
- self.assertTrue((a * 0).__class__ is tuple)\r
- self.assertTrue((a * 1).__class__ is tuple)\r
- self.assertTrue((a * 2).__class__ is tuple)\r
- self.assertTrue(a[:].__class__ is tuple)\r
-\r
- class madstring(str):\r
- _rev = None\r
- def rev(self):\r
- if self._rev is not None:\r
- return self._rev\r
- L = list(self)\r
- L.reverse()\r
- self._rev = self.__class__("".join(L))\r
- return self._rev\r
- s = madstring("abcdefghijklmnopqrstuvwxyz")\r
- self.assertEqual(s, "abcdefghijklmnopqrstuvwxyz")\r
- self.assertEqual(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba"))\r
- self.assertEqual(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz"))\r
- for i in range(256):\r
- s = madstring("".join(map(chr, range(i))))\r
- t = s.rev()\r
- u = t.rev()\r
- self.assertEqual(u, s)\r
- s = madstring("12345")\r
- self.assertEqual(str(s), "12345")\r
- self.assertTrue(str(s).__class__ is str)\r
-\r
- base = "\x00" * 5\r
- s = madstring(base)\r
- self.assertEqual(s, base)\r
- self.assertEqual(str(s), base)\r
- self.assertTrue(str(s).__class__ is str)\r
- self.assertEqual(hash(s), hash(base))\r
- self.assertEqual({s: 1}[base], 1)\r
- self.assertEqual({base: 1}[s], 1)\r
- self.assertTrue((s + "").__class__ is str)\r
- self.assertEqual(s + "", base)\r
- self.assertTrue(("" + s).__class__ is str)\r
- self.assertEqual("" + s, base)\r
- self.assertTrue((s * 0).__class__ is str)\r
- self.assertEqual(s * 0, "")\r
- self.assertTrue((s * 1).__class__ is str)\r
- self.assertEqual(s * 1, base)\r
- self.assertTrue((s * 2).__class__ is str)\r
- self.assertEqual(s * 2, base + base)\r
- self.assertTrue(s[:].__class__ is str)\r
- self.assertEqual(s[:], base)\r
- self.assertTrue(s[0:0].__class__ is str)\r
- self.assertEqual(s[0:0], "")\r
- self.assertTrue(s.strip().__class__ is str)\r
- self.assertEqual(s.strip(), base)\r
- self.assertTrue(s.lstrip().__class__ is str)\r
- self.assertEqual(s.lstrip(), base)\r
- self.assertTrue(s.rstrip().__class__ is str)\r
- self.assertEqual(s.rstrip(), base)\r
- identitytab = ''.join([chr(i) for i in range(256)])\r
- self.assertTrue(s.translate(identitytab).__class__ is str)\r
- self.assertEqual(s.translate(identitytab), base)\r
- self.assertTrue(s.translate(identitytab, "x").__class__ is str)\r
- self.assertEqual(s.translate(identitytab, "x"), base)\r
- self.assertEqual(s.translate(identitytab, "\x00"), "")\r
- self.assertTrue(s.replace("x", "x").__class__ is str)\r
- self.assertEqual(s.replace("x", "x"), base)\r
- self.assertTrue(s.ljust(len(s)).__class__ is str)\r
- self.assertEqual(s.ljust(len(s)), base)\r
- self.assertTrue(s.rjust(len(s)).__class__ is str)\r
- self.assertEqual(s.rjust(len(s)), base)\r
- self.assertTrue(s.center(len(s)).__class__ is str)\r
- self.assertEqual(s.center(len(s)), base)\r
- self.assertTrue(s.lower().__class__ is str)\r
- self.assertEqual(s.lower(), base)\r
-\r
- class madunicode(unicode):\r
- _rev = None\r
- def rev(self):\r
- if self._rev is not None:\r
- return self._rev\r
- L = list(self)\r
- L.reverse()\r
- self._rev = self.__class__(u"".join(L))\r
- return self._rev\r
- u = madunicode("ABCDEF")\r
- self.assertEqual(u, u"ABCDEF")\r
- self.assertEqual(u.rev(), madunicode(u"FEDCBA"))\r
- self.assertEqual(u.rev().rev(), madunicode(u"ABCDEF"))\r
- base = u"12345"\r
- u = madunicode(base)\r
- self.assertEqual(unicode(u), base)\r
- self.assertTrue(unicode(u).__class__ is unicode)\r
- self.assertEqual(hash(u), hash(base))\r
- self.assertEqual({u: 1}[base], 1)\r
- self.assertEqual({base: 1}[u], 1)\r
- self.assertTrue(u.strip().__class__ is unicode)\r
- self.assertEqual(u.strip(), base)\r
- self.assertTrue(u.lstrip().__class__ is unicode)\r
- self.assertEqual(u.lstrip(), base)\r
- self.assertTrue(u.rstrip().__class__ is unicode)\r
- self.assertEqual(u.rstrip(), base)\r
- self.assertTrue(u.replace(u"x", u"x").__class__ is unicode)\r
- self.assertEqual(u.replace(u"x", u"x"), base)\r
- self.assertTrue(u.replace(u"xy", u"xy").__class__ is unicode)\r
- self.assertEqual(u.replace(u"xy", u"xy"), base)\r
- self.assertTrue(u.center(len(u)).__class__ is unicode)\r
- self.assertEqual(u.center(len(u)), base)\r
- self.assertTrue(u.ljust(len(u)).__class__ is unicode)\r
- self.assertEqual(u.ljust(len(u)), base)\r
- self.assertTrue(u.rjust(len(u)).__class__ is unicode)\r
- self.assertEqual(u.rjust(len(u)), base)\r
- self.assertTrue(u.lower().__class__ is unicode)\r
- self.assertEqual(u.lower(), base)\r
- self.assertTrue(u.upper().__class__ is unicode)\r
- self.assertEqual(u.upper(), base)\r
- self.assertTrue(u.capitalize().__class__ is unicode)\r
- self.assertEqual(u.capitalize(), base)\r
- self.assertTrue(u.title().__class__ is unicode)\r
- self.assertEqual(u.title(), base)\r
- self.assertTrue((u + u"").__class__ is unicode)\r
- self.assertEqual(u + u"", base)\r
- self.assertTrue((u"" + u).__class__ is unicode)\r
- self.assertEqual(u"" + u, base)\r
- self.assertTrue((u * 0).__class__ is unicode)\r
- self.assertEqual(u * 0, u"")\r
- self.assertTrue((u * 1).__class__ is unicode)\r
- self.assertEqual(u * 1, base)\r
- self.assertTrue((u * 2).__class__ is unicode)\r
- self.assertEqual(u * 2, base + base)\r
- self.assertTrue(u[:].__class__ is unicode)\r
- self.assertEqual(u[:], base)\r
- self.assertTrue(u[0:0].__class__ is unicode)\r
- self.assertEqual(u[0:0], u"")\r
-\r
- class sublist(list):\r
- pass\r
- a = sublist(range(5))\r
- self.assertEqual(a, range(5))\r
- a.append("hello")\r
- self.assertEqual(a, range(5) + ["hello"])\r
- a[5] = 5\r
- self.assertEqual(a, range(6))\r
- a.extend(range(6, 20))\r
- self.assertEqual(a, range(20))\r
- a[-5:] = []\r
- self.assertEqual(a, range(15))\r
- del a[10:15]\r
- self.assertEqual(len(a), 10)\r
- self.assertEqual(a, range(10))\r
- self.assertEqual(list(a), range(10))\r
- self.assertEqual(a[0], 0)\r
- self.assertEqual(a[9], 9)\r
- self.assertEqual(a[-10], 0)\r
- self.assertEqual(a[-1], 9)\r
- self.assertEqual(a[:5], range(5))\r
-\r
- class CountedInput(file):\r
- """Counts lines read by self.readline().\r
-\r
- self.lineno is the 0-based ordinal of the last line read, up to\r
- a maximum of one greater than the number of lines in the file.\r
-\r
- self.ateof is true if and only if the final "" line has been read,\r
- at which point self.lineno stops incrementing, and further calls\r
- to readline() continue to return "".\r
- """\r
-\r
- lineno = 0\r
- ateof = 0\r
- def readline(self):\r
- if self.ateof:\r
- return ""\r
- s = file.readline(self)\r
- # Next line works too.\r
- # s = super(CountedInput, self).readline()\r
- self.lineno += 1\r
- if s == "":\r
- self.ateof = 1\r
- return s\r
-\r
- f = file(name=test_support.TESTFN, mode='w')\r
- lines = ['a\n', 'b\n', 'c\n']\r
- try:\r
- f.writelines(lines)\r
- f.close()\r
- f = CountedInput(test_support.TESTFN)\r
- for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]):\r
- got = f.readline()\r
- self.assertEqual(expected, got)\r
- self.assertEqual(f.lineno, i)\r
- self.assertEqual(f.ateof, (i > len(lines)))\r
- f.close()\r
- finally:\r
- try:\r
- f.close()\r
- except:\r
- pass\r
- test_support.unlink(test_support.TESTFN)\r
-\r
- def test_keywords(self):\r
- # Testing keyword args to basic type constructors ...\r
- self.assertEqual(int(x=1), 1)\r
- self.assertEqual(float(x=2), 2.0)\r
- self.assertEqual(long(x=3), 3L)\r
- self.assertEqual(complex(imag=42, real=666), complex(666, 42))\r
- self.assertEqual(str(object=500), '500')\r
- self.assertEqual(unicode(string='abc', errors='strict'), u'abc')\r
- self.assertEqual(tuple(sequence=range(3)), (0, 1, 2))\r
- self.assertEqual(list(sequence=(0, 1, 2)), range(3))\r
- # note: as of Python 2.3, dict() no longer has an "items" keyword arg\r
-\r
- for constructor in (int, float, long, complex, str, unicode,\r
- tuple, list, file):\r
- try:\r
- constructor(bogus_keyword_arg=1)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected TypeError from bogus keyword argument to %r"\r
- % constructor)\r
-\r
- def test_str_subclass_as_dict_key(self):\r
- # Testing a str subclass used as dict key ..\r
-\r
- class cistr(str):\r
- """Sublcass of str that computes __eq__ case-insensitively.\r
-\r
- Also computes a hash code of the string in canonical form.\r
- """\r
-\r
- def __init__(self, value):\r
- self.canonical = value.lower()\r
- self.hashcode = hash(self.canonical)\r
-\r
- def __eq__(self, other):\r
- if not isinstance(other, cistr):\r
- other = cistr(other)\r
- return self.canonical == other.canonical\r
-\r
- def __hash__(self):\r
- return self.hashcode\r
-\r
- self.assertEqual(cistr('ABC'), 'abc')\r
- self.assertEqual('aBc', cistr('ABC'))\r
- self.assertEqual(str(cistr('ABC')), 'ABC')\r
-\r
- d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3}\r
- self.assertEqual(d[cistr('one')], 1)\r
- self.assertEqual(d[cistr('tWo')], 2)\r
- self.assertEqual(d[cistr('THrEE')], 3)\r
- self.assertIn(cistr('ONe'), d)\r
- self.assertEqual(d.get(cistr('thrEE')), 3)\r
-\r
- def test_classic_comparisons(self):\r
- # Testing classic comparisons...\r
- class classic:\r
- pass\r
-\r
- for base in (classic, int, object):\r
- class C(base):\r
- def __init__(self, value):\r
- self.value = int(value)\r
- def __cmp__(self, other):\r
- if isinstance(other, C):\r
- return cmp(self.value, other.value)\r
- if isinstance(other, int) or isinstance(other, long):\r
- return cmp(self.value, other)\r
- return NotImplemented\r
- __hash__ = None # Silence Py3k warning\r
-\r
- c1 = C(1)\r
- c2 = C(2)\r
- c3 = C(3)\r
- self.assertEqual(c1, 1)\r
- c = {1: c1, 2: c2, 3: c3}\r
- for x in 1, 2, 3:\r
- for y in 1, 2, 3:\r
- self.assertTrue(cmp(c[x], c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))\r
- for op in "<", "<=", "==", "!=", ">", ">=":\r
- self.assertTrue(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),\r
- "x=%d, y=%d" % (x, y))\r
- self.assertTrue(cmp(c[x], y) == cmp(x, y), "x=%d, y=%d" % (x, y))\r
- self.assertTrue(cmp(x, c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))\r
-\r
- def test_rich_comparisons(self):\r
- # Testing rich comparisons...\r
- class Z(complex):\r
- pass\r
- z = Z(1)\r
- self.assertEqual(z, 1+0j)\r
- self.assertEqual(1+0j, z)\r
- class ZZ(complex):\r
- def __eq__(self, other):\r
- try:\r
- return abs(self - other) <= 1e-6\r
- except:\r
- return NotImplemented\r
- __hash__ = None # Silence Py3k warning\r
- zz = ZZ(1.0000003)\r
- self.assertEqual(zz, 1+0j)\r
- self.assertEqual(1+0j, zz)\r
-\r
- class classic:\r
- pass\r
- for base in (classic, int, object, list):\r
- class C(base):\r
- def __init__(self, value):\r
- self.value = int(value)\r
- def __cmp__(self_, other):\r
- self.fail("shouldn't call __cmp__")\r
- __hash__ = None # Silence Py3k warning\r
- def __eq__(self, other):\r
- if isinstance(other, C):\r
- return self.value == other.value\r
- if isinstance(other, int) or isinstance(other, long):\r
- return self.value == other\r
- return NotImplemented\r
- def __ne__(self, other):\r
- if isinstance(other, C):\r
- return self.value != other.value\r
- if isinstance(other, int) or isinstance(other, long):\r
- return self.value != other\r
- return NotImplemented\r
- def __lt__(self, other):\r
- if isinstance(other, C):\r
- return self.value < other.value\r
- if isinstance(other, int) or isinstance(other, long):\r
- return self.value < other\r
- return NotImplemented\r
- def __le__(self, other):\r
- if isinstance(other, C):\r
- return self.value <= other.value\r
- if isinstance(other, int) or isinstance(other, long):\r
- return self.value <= other\r
- return NotImplemented\r
- def __gt__(self, other):\r
- if isinstance(other, C):\r
- return self.value > other.value\r
- if isinstance(other, int) or isinstance(other, long):\r
- return self.value > other\r
- return NotImplemented\r
- def __ge__(self, other):\r
- if isinstance(other, C):\r
- return self.value >= other.value\r
- if isinstance(other, int) or isinstance(other, long):\r
- return self.value >= other\r
- return NotImplemented\r
- c1 = C(1)\r
- c2 = C(2)\r
- c3 = C(3)\r
- self.assertEqual(c1, 1)\r
- c = {1: c1, 2: c2, 3: c3}\r
- for x in 1, 2, 3:\r
- for y in 1, 2, 3:\r
- for op in "<", "<=", "==", "!=", ">", ">=":\r
- self.assertTrue(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),\r
- "x=%d, y=%d" % (x, y))\r
- self.assertTrue(eval("c[x] %s y" % op) == eval("x %s y" % op),\r
- "x=%d, y=%d" % (x, y))\r
- self.assertTrue(eval("x %s c[y]" % op) == eval("x %s y" % op),\r
- "x=%d, y=%d" % (x, y))\r
-\r
- def test_coercions(self):\r
- # Testing coercions...\r
- class I(int): pass\r
- coerce(I(0), 0)\r
- coerce(0, I(0))\r
- class L(long): pass\r
- coerce(L(0), 0)\r
- coerce(L(0), 0L)\r
- coerce(0, L(0))\r
- coerce(0L, L(0))\r
- class F(float): pass\r
- coerce(F(0), 0)\r
- coerce(F(0), 0L)\r
- coerce(F(0), 0.)\r
- coerce(0, F(0))\r
- coerce(0L, F(0))\r
- coerce(0., F(0))\r
- class C(complex): pass\r
- coerce(C(0), 0)\r
- coerce(C(0), 0L)\r
- coerce(C(0), 0.)\r
- coerce(C(0), 0j)\r
- coerce(0, C(0))\r
- coerce(0L, C(0))\r
- coerce(0., C(0))\r
- coerce(0j, C(0))\r
-\r
- def test_descrdoc(self):\r
- # Testing descriptor doc strings...\r
- def check(descr, what):\r
- self.assertEqual(descr.__doc__, what)\r
- check(file.closed, "True if the file is closed") # getset descriptor\r
- check(file.name, "file name") # member descriptor\r
-\r
- def test_doc_descriptor(self):\r
- # Testing __doc__ descriptor...\r
- # SF bug 542984\r
- class DocDescr(object):\r
- def __get__(self, object, otype):\r
- if object:\r
- object = object.__class__.__name__ + ' instance'\r
- if otype:\r
- otype = otype.__name__\r
- return 'object=%s; type=%s' % (object, otype)\r
- class OldClass:\r
- __doc__ = DocDescr()\r
- class NewClass(object):\r
- __doc__ = DocDescr()\r
- self.assertEqual(OldClass.__doc__, 'object=None; type=OldClass')\r
- self.assertEqual(OldClass().__doc__, 'object=OldClass instance; type=OldClass')\r
- self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass')\r
- self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass')\r
-\r
- def test_set_class(self):\r
- # Testing __class__ assignment...\r
- class C(object): pass\r
- class D(object): pass\r
- class E(object): pass\r
- class F(D, E): pass\r
- for cls in C, D, E, F:\r
- for cls2 in C, D, E, F:\r
- x = cls()\r
- x.__class__ = cls2\r
- self.assertTrue(x.__class__ is cls2)\r
- x.__class__ = cls\r
- self.assertTrue(x.__class__ is cls)\r
- def cant(x, C):\r
- try:\r
- x.__class__ = C\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't allow %r.__class__ = %r" % (x, C))\r
- try:\r
- delattr(x, "__class__")\r
- except (TypeError, AttributeError):\r
- pass\r
- else:\r
- self.fail("shouldn't allow del %r.__class__" % x)\r
- cant(C(), list)\r
- cant(list(), C)\r
- cant(C(), 1)\r
- cant(C(), object)\r
- cant(object(), list)\r
- cant(list(), object)\r
- class Int(int): __slots__ = []\r
- cant(2, Int)\r
- cant(Int(), int)\r
- cant(True, int)\r
- cant(2, bool)\r
- o = object()\r
- cant(o, type(1))\r
- cant(o, type(None))\r
- del o\r
- class G(object):\r
- __slots__ = ["a", "b"]\r
- class H(object):\r
- __slots__ = ["b", "a"]\r
- try:\r
- unicode\r
- except NameError:\r
- class I(object):\r
- __slots__ = ["a", "b"]\r
- else:\r
- class I(object):\r
- __slots__ = [unicode("a"), unicode("b")]\r
- class J(object):\r
- __slots__ = ["c", "b"]\r
- class K(object):\r
- __slots__ = ["a", "b", "d"]\r
- class L(H):\r
- __slots__ = ["e"]\r
- class M(I):\r
- __slots__ = ["e"]\r
- class N(J):\r
- __slots__ = ["__weakref__"]\r
- class P(J):\r
- __slots__ = ["__dict__"]\r
- class Q(J):\r
- pass\r
- class R(J):\r
- __slots__ = ["__dict__", "__weakref__"]\r
-\r
- for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)):\r
- x = cls()\r
- x.a = 1\r
- x.__class__ = cls2\r
- self.assertTrue(x.__class__ is cls2,\r
- "assigning %r as __class__ for %r silently failed" % (cls2, x))\r
- self.assertEqual(x.a, 1)\r
- x.__class__ = cls\r
- self.assertTrue(x.__class__ is cls,\r
- "assigning %r as __class__ for %r silently failed" % (cls, x))\r
- self.assertEqual(x.a, 1)\r
- for cls in G, J, K, L, M, N, P, R, list, Int:\r
- for cls2 in G, J, K, L, M, N, P, R, list, Int:\r
- if cls is cls2:\r
- continue\r
- cant(cls(), cls2)\r
-\r
- # Issue5283: when __class__ changes in __del__, the wrong\r
- # type gets DECREF'd.\r
- class O(object):\r
- pass\r
- class A(object):\r
- def __del__(self):\r
- self.__class__ = O\r
- l = [A() for x in range(100)]\r
- del l\r
-\r
- def test_set_dict(self):\r
- # Testing __dict__ assignment...\r
- class C(object): pass\r
- a = C()\r
- a.__dict__ = {'b': 1}\r
- self.assertEqual(a.b, 1)\r
- def cant(x, dict):\r
- try:\r
- x.__dict__ = dict\r
- except (AttributeError, TypeError):\r
- pass\r
- else:\r
- self.fail("shouldn't allow %r.__dict__ = %r" % (x, dict))\r
- cant(a, None)\r
- cant(a, [])\r
- cant(a, 1)\r
- del a.__dict__ # Deleting __dict__ is allowed\r
-\r
- class Base(object):\r
- pass\r
- def verify_dict_readonly(x):\r
- """\r
- x has to be an instance of a class inheriting from Base.\r
- """\r
- cant(x, {})\r
- try:\r
- del x.__dict__\r
- except (AttributeError, TypeError):\r
- pass\r
- else:\r
- self.fail("shouldn't allow del %r.__dict__" % x)\r
- dict_descr = Base.__dict__["__dict__"]\r
- try:\r
- dict_descr.__set__(x, {})\r
- except (AttributeError, TypeError):\r
- pass\r
- else:\r
- self.fail("dict_descr allowed access to %r's dict" % x)\r
-\r
- # Classes don't allow __dict__ assignment and have readonly dicts\r
- class Meta1(type, Base):\r
- pass\r
- class Meta2(Base, type):\r
- pass\r
- class D(object):\r
- __metaclass__ = Meta1\r
- class E(object):\r
- __metaclass__ = Meta2\r
- for cls in C, D, E:\r
- verify_dict_readonly(cls)\r
- class_dict = cls.__dict__\r
- try:\r
- class_dict["spam"] = "eggs"\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("%r's __dict__ can be modified" % cls)\r
-\r
- # Modules also disallow __dict__ assignment\r
- class Module1(types.ModuleType, Base):\r
- pass\r
- class Module2(Base, types.ModuleType):\r
- pass\r
- for ModuleType in Module1, Module2:\r
- mod = ModuleType("spam")\r
- verify_dict_readonly(mod)\r
- mod.__dict__["spam"] = "eggs"\r
-\r
- # Exception's __dict__ can be replaced, but not deleted\r
- # (at least not any more than regular exception's __dict__ can\r
- # be deleted; on CPython it is not the case, whereas on PyPy they\r
- # can, just like any other new-style instance's __dict__.)\r
- def can_delete_dict(e):\r
- try:\r
- del e.__dict__\r
- except (TypeError, AttributeError):\r
- return False\r
- else:\r
- return True\r
- class Exception1(Exception, Base):\r
- pass\r
- class Exception2(Base, Exception):\r
- pass\r
- for ExceptionType in Exception, Exception1, Exception2:\r
- e = ExceptionType()\r
- e.__dict__ = {"a": 1}\r
- self.assertEqual(e.a, 1)\r
- self.assertEqual(can_delete_dict(e), can_delete_dict(ValueError()))\r
-\r
- def test_pickles(self):\r
- # Testing pickling and copying new-style classes and objects...\r
- import pickle, cPickle\r
-\r
- def sorteditems(d):\r
- L = d.items()\r
- L.sort()\r
- return L\r
-\r
- global C\r
- class C(object):\r
- def __init__(self, a, b):\r
- super(C, self).__init__()\r
- self.a = a\r
- self.b = b\r
- def __repr__(self):\r
- return "C(%r, %r)" % (self.a, self.b)\r
-\r
- global C1\r
- class C1(list):\r
- def __new__(cls, a, b):\r
- return super(C1, cls).__new__(cls)\r
- def __getnewargs__(self):\r
- return (self.a, self.b)\r
- def __init__(self, a, b):\r
- self.a = a\r
- self.b = b\r
- def __repr__(self):\r
- return "C1(%r, %r)<%r>" % (self.a, self.b, list(self))\r
-\r
- global C2\r
- class C2(int):\r
- def __new__(cls, a, b, val=0):\r
- return super(C2, cls).__new__(cls, val)\r
- def __getnewargs__(self):\r
- return (self.a, self.b, int(self))\r
- def __init__(self, a, b, val=0):\r
- self.a = a\r
- self.b = b\r
- def __repr__(self):\r
- return "C2(%r, %r)<%r>" % (self.a, self.b, int(self))\r
-\r
- global C3\r
- class C3(object):\r
- def __init__(self, foo):\r
- self.foo = foo\r
- def __getstate__(self):\r
- return self.foo\r
- def __setstate__(self, foo):\r
- self.foo = foo\r
-\r
- global C4classic, C4\r
- class C4classic: # classic\r
- pass\r
- class C4(C4classic, object): # mixed inheritance\r
- pass\r
-\r
- for p in pickle, cPickle:\r
- for bin in 0, 1:\r
- for cls in C, C1, C2:\r
- s = p.dumps(cls, bin)\r
- cls2 = p.loads(s)\r
- self.assertTrue(cls2 is cls)\r
-\r
- a = C1(1, 2); a.append(42); a.append(24)\r
- b = C2("hello", "world", 42)\r
- s = p.dumps((a, b), bin)\r
- x, y = p.loads(s)\r
- self.assertEqual(x.__class__, a.__class__)\r
- self.assertEqual(sorteditems(x.__dict__), sorteditems(a.__dict__))\r
- self.assertEqual(y.__class__, b.__class__)\r
- self.assertEqual(sorteditems(y.__dict__), sorteditems(b.__dict__))\r
- self.assertEqual(repr(x), repr(a))\r
- self.assertEqual(repr(y), repr(b))\r
- # Test for __getstate__ and __setstate__ on new style class\r
- u = C3(42)\r
- s = p.dumps(u, bin)\r
- v = p.loads(s)\r
- self.assertEqual(u.__class__, v.__class__)\r
- self.assertEqual(u.foo, v.foo)\r
- # Test for picklability of hybrid class\r
- u = C4()\r
- u.foo = 42\r
- s = p.dumps(u, bin)\r
- v = p.loads(s)\r
- self.assertEqual(u.__class__, v.__class__)\r
- self.assertEqual(u.foo, v.foo)\r
-\r
- # Testing copy.deepcopy()\r
- import copy\r
- for cls in C, C1, C2:\r
- cls2 = copy.deepcopy(cls)\r
- self.assertTrue(cls2 is cls)\r
-\r
- a = C1(1, 2); a.append(42); a.append(24)\r
- b = C2("hello", "world", 42)\r
- x, y = copy.deepcopy((a, b))\r
- self.assertEqual(x.__class__, a.__class__)\r
- self.assertEqual(sorteditems(x.__dict__), sorteditems(a.__dict__))\r
- self.assertEqual(y.__class__, b.__class__)\r
- self.assertEqual(sorteditems(y.__dict__), sorteditems(b.__dict__))\r
- self.assertEqual(repr(x), repr(a))\r
- self.assertEqual(repr(y), repr(b))\r
-\r
- def test_pickle_slots(self):\r
- # Testing pickling of classes with __slots__ ...\r
- import pickle, cPickle\r
- # Pickling of classes with __slots__ but without __getstate__ should fail\r
- global B, C, D, E\r
- class B(object):\r
- pass\r
- for base in [object, B]:\r
- class C(base):\r
- __slots__ = ['a']\r
- class D(C):\r
- pass\r
- try:\r
- pickle.dumps(C())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("should fail: pickle C instance - %s" % base)\r
- try:\r
- cPickle.dumps(C())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("should fail: cPickle C instance - %s" % base)\r
- try:\r
- pickle.dumps(C())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("should fail: pickle D instance - %s" % base)\r
- try:\r
- cPickle.dumps(D())\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("should fail: cPickle D instance - %s" % base)\r
- # Give C a nice generic __getstate__ and __setstate__\r
- class C(base):\r
- __slots__ = ['a']\r
- def __getstate__(self):\r
- try:\r
- d = self.__dict__.copy()\r
- except AttributeError:\r
- d = {}\r
- for cls in self.__class__.__mro__:\r
- for sn in cls.__dict__.get('__slots__', ()):\r
- try:\r
- d[sn] = getattr(self, sn)\r
- except AttributeError:\r
- pass\r
- return d\r
- def __setstate__(self, d):\r
- for k, v in d.items():\r
- setattr(self, k, v)\r
- class D(C):\r
- pass\r
- # Now it should work\r
- x = C()\r
- y = pickle.loads(pickle.dumps(x))\r
- self.assertEqual(hasattr(y, 'a'), 0)\r
- y = cPickle.loads(cPickle.dumps(x))\r
- self.assertEqual(hasattr(y, 'a'), 0)\r
- x.a = 42\r
- y = pickle.loads(pickle.dumps(x))\r
- self.assertEqual(y.a, 42)\r
- y = cPickle.loads(cPickle.dumps(x))\r
- self.assertEqual(y.a, 42)\r
- x = D()\r
- x.a = 42\r
- x.b = 100\r
- y = pickle.loads(pickle.dumps(x))\r
- self.assertEqual(y.a + y.b, 142)\r
- y = cPickle.loads(cPickle.dumps(x))\r
- self.assertEqual(y.a + y.b, 142)\r
- # A subclass that adds a slot should also work\r
- class E(C):\r
- __slots__ = ['b']\r
- x = E()\r
- x.a = 42\r
- x.b = "foo"\r
- y = pickle.loads(pickle.dumps(x))\r
- self.assertEqual(y.a, x.a)\r
- self.assertEqual(y.b, x.b)\r
- y = cPickle.loads(cPickle.dumps(x))\r
- self.assertEqual(y.a, x.a)\r
- self.assertEqual(y.b, x.b)\r
-\r
- def test_binary_operator_override(self):\r
- # Testing overrides of binary operations...\r
- class I(int):\r
- def __repr__(self):\r
- return "I(%r)" % int(self)\r
- def __add__(self, other):\r
- return I(int(self) + int(other))\r
- __radd__ = __add__\r
- def __pow__(self, other, mod=None):\r
- if mod is None:\r
- return I(pow(int(self), int(other)))\r
- else:\r
- return I(pow(int(self), int(other), int(mod)))\r
- def __rpow__(self, other, mod=None):\r
- if mod is None:\r
- return I(pow(int(other), int(self), mod))\r
- else:\r
- return I(pow(int(other), int(self), int(mod)))\r
-\r
- self.assertEqual(repr(I(1) + I(2)), "I(3)")\r
- self.assertEqual(repr(I(1) + 2), "I(3)")\r
- self.assertEqual(repr(1 + I(2)), "I(3)")\r
- self.assertEqual(repr(I(2) ** I(3)), "I(8)")\r
- self.assertEqual(repr(2 ** I(3)), "I(8)")\r
- self.assertEqual(repr(I(2) ** 3), "I(8)")\r
- self.assertEqual(repr(pow(I(2), I(3), I(5))), "I(3)")\r
- class S(str):\r
- def __eq__(self, other):\r
- return self.lower() == other.lower()\r
- __hash__ = None # Silence Py3k warning\r
-\r
- def test_subclass_propagation(self):\r
- # Testing propagation of slot functions to subclasses...\r
- class A(object):\r
- pass\r
- class B(A):\r
- pass\r
- class C(A):\r
- pass\r
- class D(B, C):\r
- pass\r
- d = D()\r
- orig_hash = hash(d) # related to id(d) in platform-dependent ways\r
- A.__hash__ = lambda self: 42\r
- self.assertEqual(hash(d), 42)\r
- C.__hash__ = lambda self: 314\r
- self.assertEqual(hash(d), 314)\r
- B.__hash__ = lambda self: 144\r
- self.assertEqual(hash(d), 144)\r
- D.__hash__ = lambda self: 100\r
- self.assertEqual(hash(d), 100)\r
- D.__hash__ = None\r
- self.assertRaises(TypeError, hash, d)\r
- del D.__hash__\r
- self.assertEqual(hash(d), 144)\r
- B.__hash__ = None\r
- self.assertRaises(TypeError, hash, d)\r
- del B.__hash__\r
- self.assertEqual(hash(d), 314)\r
- C.__hash__ = None\r
- self.assertRaises(TypeError, hash, d)\r
- del C.__hash__\r
- self.assertEqual(hash(d), 42)\r
- A.__hash__ = None\r
- self.assertRaises(TypeError, hash, d)\r
- del A.__hash__\r
- self.assertEqual(hash(d), orig_hash)\r
- d.foo = 42\r
- d.bar = 42\r
- self.assertEqual(d.foo, 42)\r
- self.assertEqual(d.bar, 42)\r
- def __getattribute__(self, name):\r
- if name == "foo":\r
- return 24\r
- return object.__getattribute__(self, name)\r
- A.__getattribute__ = __getattribute__\r
- self.assertEqual(d.foo, 24)\r
- self.assertEqual(d.bar, 42)\r
- def __getattr__(self, name):\r
- if name in ("spam", "foo", "bar"):\r
- return "hello"\r
- raise AttributeError, name\r
- B.__getattr__ = __getattr__\r
- self.assertEqual(d.spam, "hello")\r
- self.assertEqual(d.foo, 24)\r
- self.assertEqual(d.bar, 42)\r
- del A.__getattribute__\r
- self.assertEqual(d.foo, 42)\r
- del d.foo\r
- self.assertEqual(d.foo, "hello")\r
- self.assertEqual(d.bar, 42)\r
- del B.__getattr__\r
- try:\r
- d.foo\r
- except AttributeError:\r
- pass\r
- else:\r
- self.fail("d.foo should be undefined now")\r
-\r
- # Test a nasty bug in recurse_down_subclasses()\r
- class A(object):\r
- pass\r
- class B(A):\r
- pass\r
- del B\r
- test_support.gc_collect()\r
- A.__setitem__ = lambda *a: None # crash\r
-\r
- def test_buffer_inheritance(self):\r
- # Testing that buffer interface is inherited ...\r
-\r
- import binascii\r
- # SF bug [#470040] ParseTuple t# vs subclasses.\r
-\r
- class MyStr(str):\r
- pass\r
- base = 'abc'\r
- m = MyStr(base)\r
- # b2a_hex uses the buffer interface to get its argument's value, via\r
- # PyArg_ParseTuple 't#' code.\r
- self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base))\r
-\r
- # It's not clear that unicode will continue to support the character\r
- # buffer interface, and this test will fail if that's taken away.\r
- class MyUni(unicode):\r
- pass\r
- base = u'abc'\r
- m = MyUni(base)\r
- self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base))\r
-\r
- class MyInt(int):\r
- pass\r
- m = MyInt(42)\r
- try:\r
- binascii.b2a_hex(m)\r
- self.fail('subclass of int should not have a buffer interface')\r
- except TypeError:\r
- pass\r
-\r
- def test_str_of_str_subclass(self):\r
- # Testing __str__ defined in subclass of str ...\r
- import binascii\r
- import cStringIO\r
-\r
- class octetstring(str):\r
- def __str__(self):\r
- return binascii.b2a_hex(self)\r
- def __repr__(self):\r
- return self + " repr"\r
-\r
- o = octetstring('A')\r
- self.assertEqual(type(o), octetstring)\r
- self.assertEqual(type(str(o)), str)\r
- self.assertEqual(type(repr(o)), str)\r
- self.assertEqual(ord(o), 0x41)\r
- self.assertEqual(str(o), '41')\r
- self.assertEqual(repr(o), 'A repr')\r
- self.assertEqual(o.__str__(), '41')\r
- self.assertEqual(o.__repr__(), 'A repr')\r
-\r
- capture = cStringIO.StringIO()\r
- # Calling str() or not exercises different internal paths.\r
- print >> capture, o\r
- print >> capture, str(o)\r
- self.assertEqual(capture.getvalue(), '41\n41\n')\r
- capture.close()\r
-\r
- def test_keyword_arguments(self):\r
- # Testing keyword arguments to __init__, __call__...\r
- def f(a): return a\r
- self.assertEqual(f.__call__(a=42), 42)\r
- a = []\r
- list.__init__(a, sequence=[0, 1, 2])\r
- self.assertEqual(a, [0, 1, 2])\r
-\r
- def test_recursive_call(self):\r
- # Testing recursive __call__() by setting to instance of class...\r
- class A(object):\r
- pass\r
-\r
- A.__call__ = A()\r
- try:\r
- A()()\r
- except RuntimeError:\r
- pass\r
- else:\r
- self.fail("Recursion limit should have been reached for __call__()")\r
-\r
- def test_delete_hook(self):\r
- # Testing __del__ hook...\r
- log = []\r
- class C(object):\r
- def __del__(self):\r
- log.append(1)\r
- c = C()\r
- self.assertEqual(log, [])\r
- del c\r
- test_support.gc_collect()\r
- self.assertEqual(log, [1])\r
-\r
- class D(object): pass\r
- d = D()\r
- try: del d[0]\r
- except TypeError: pass\r
- else: self.fail("invalid del() didn't raise TypeError")\r
-\r
- def test_hash_inheritance(self):\r
- # Testing hash of mutable subclasses...\r
-\r
- class mydict(dict):\r
- pass\r
- d = mydict()\r
- try:\r
- hash(d)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("hash() of dict subclass should fail")\r
-\r
- class mylist(list):\r
- pass\r
- d = mylist()\r
- try:\r
- hash(d)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("hash() of list subclass should fail")\r
-\r
- def test_str_operations(self):\r
- try: 'a' + 5\r
- except TypeError: pass\r
- else: self.fail("'' + 5 doesn't raise TypeError")\r
-\r
- try: ''.split('')\r
- except ValueError: pass\r
- else: self.fail("''.split('') doesn't raise ValueError")\r
-\r
- try: ''.join([0])\r
- except TypeError: pass\r
- else: self.fail("''.join([0]) doesn't raise TypeError")\r
-\r
- try: ''.rindex('5')\r
- except ValueError: pass\r
- else: self.fail("''.rindex('5') doesn't raise ValueError")\r
-\r
- try: '%(n)s' % None\r
- except TypeError: pass\r
- else: self.fail("'%(n)s' % None doesn't raise TypeError")\r
-\r
- try: '%(n' % {}\r
- except ValueError: pass\r
- else: self.fail("'%(n' % {} '' doesn't raise ValueError")\r
-\r
- try: '%*s' % ('abc')\r
- except TypeError: pass\r
- else: self.fail("'%*s' % ('abc') doesn't raise TypeError")\r
-\r
- try: '%*.*s' % ('abc', 5)\r
- except TypeError: pass\r
- else: self.fail("'%*.*s' % ('abc', 5) doesn't raise TypeError")\r
-\r
- try: '%s' % (1, 2)\r
- except TypeError: pass\r
- else: self.fail("'%s' % (1, 2) doesn't raise TypeError")\r
-\r
- try: '%' % None\r
- except ValueError: pass\r
- else: self.fail("'%' % None doesn't raise ValueError")\r
-\r
- self.assertEqual('534253'.isdigit(), 1)\r
- self.assertEqual('534253x'.isdigit(), 0)\r
- self.assertEqual('%c' % 5, '\x05')\r
- self.assertEqual('%c' % '5', '5')\r
-\r
- def test_deepcopy_recursive(self):\r
- # Testing deepcopy of recursive objects...\r
- class Node:\r
- pass\r
- a = Node()\r
- b = Node()\r
- a.b = b\r
- b.a = a\r
- z = deepcopy(a) # This blew up before\r
-\r
- def test_unintialized_modules(self):\r
- # Testing uninitialized module objects...\r
- from types import ModuleType as M\r
- m = M.__new__(M)\r
- str(m)\r
- self.assertEqual(hasattr(m, "__name__"), 0)\r
- self.assertEqual(hasattr(m, "__file__"), 0)\r
- self.assertEqual(hasattr(m, "foo"), 0)\r
- self.assertFalse(m.__dict__) # None or {} are both reasonable answers\r
- m.foo = 1\r
- self.assertEqual(m.__dict__, {"foo": 1})\r
-\r
- def test_funny_new(self):\r
- # Testing __new__ returning something unexpected...\r
- class C(object):\r
- def __new__(cls, arg):\r
- if isinstance(arg, str): return [1, 2, 3]\r
- elif isinstance(arg, int): return object.__new__(D)\r
- else: return object.__new__(cls)\r
- class D(C):\r
- def __init__(self, arg):\r
- self.foo = arg\r
- self.assertEqual(C("1"), [1, 2, 3])\r
- self.assertEqual(D("1"), [1, 2, 3])\r
- d = D(None)\r
- self.assertEqual(d.foo, None)\r
- d = C(1)\r
- self.assertEqual(isinstance(d, D), True)\r
- self.assertEqual(d.foo, 1)\r
- d = D(1)\r
- self.assertEqual(isinstance(d, D), True)\r
- self.assertEqual(d.foo, 1)\r
-\r
- def test_imul_bug(self):\r
- # Testing for __imul__ problems...\r
- # SF bug 544647\r
- class C(object):\r
- def __imul__(self, other):\r
- return (self, other)\r
- x = C()\r
- y = x\r
- y *= 1.0\r
- self.assertEqual(y, (x, 1.0))\r
- y = x\r
- y *= 2\r
- self.assertEqual(y, (x, 2))\r
- y = x\r
- y *= 3L\r
- self.assertEqual(y, (x, 3L))\r
- y = x\r
- y *= 1L<<100\r
- self.assertEqual(y, (x, 1L<<100))\r
- y = x\r
- y *= None\r
- self.assertEqual(y, (x, None))\r
- y = x\r
- y *= "foo"\r
- self.assertEqual(y, (x, "foo"))\r
-\r
- def test_copy_setstate(self):\r
- # Testing that copy.*copy() correctly uses __setstate__...\r
- import copy\r
- class C(object):\r
- def __init__(self, foo=None):\r
- self.foo = foo\r
- self.__foo = foo\r
- def setfoo(self, foo=None):\r
- self.foo = foo\r
- def getfoo(self):\r
- return self.__foo\r
- def __getstate__(self):\r
- return [self.foo]\r
- def __setstate__(self_, lst):\r
- self.assertEqual(len(lst), 1)\r
- self_.__foo = self_.foo = lst[0]\r
- a = C(42)\r
- a.setfoo(24)\r
- self.assertEqual(a.foo, 24)\r
- self.assertEqual(a.getfoo(), 42)\r
- b = copy.copy(a)\r
- self.assertEqual(b.foo, 24)\r
- self.assertEqual(b.getfoo(), 24)\r
- b = copy.deepcopy(a)\r
- self.assertEqual(b.foo, 24)\r
- self.assertEqual(b.getfoo(), 24)\r
-\r
- def test_slices(self):\r
- # Testing cases with slices and overridden __getitem__ ...\r
-\r
- # Strings\r
- self.assertEqual("hello"[:4], "hell")\r
- self.assertEqual("hello"[slice(4)], "hell")\r
- self.assertEqual(str.__getitem__("hello", slice(4)), "hell")\r
- class S(str):\r
- def __getitem__(self, x):\r
- return str.__getitem__(self, x)\r
- self.assertEqual(S("hello")[:4], "hell")\r
- self.assertEqual(S("hello")[slice(4)], "hell")\r
- self.assertEqual(S("hello").__getitem__(slice(4)), "hell")\r
- # Tuples\r
- self.assertEqual((1,2,3)[:2], (1,2))\r
- self.assertEqual((1,2,3)[slice(2)], (1,2))\r
- self.assertEqual(tuple.__getitem__((1,2,3), slice(2)), (1,2))\r
- class T(tuple):\r
- def __getitem__(self, x):\r
- return tuple.__getitem__(self, x)\r
- self.assertEqual(T((1,2,3))[:2], (1,2))\r
- self.assertEqual(T((1,2,3))[slice(2)], (1,2))\r
- self.assertEqual(T((1,2,3)).__getitem__(slice(2)), (1,2))\r
- # Lists\r
- self.assertEqual([1,2,3][:2], [1,2])\r
- self.assertEqual([1,2,3][slice(2)], [1,2])\r
- self.assertEqual(list.__getitem__([1,2,3], slice(2)), [1,2])\r
- class L(list):\r
- def __getitem__(self, x):\r
- return list.__getitem__(self, x)\r
- self.assertEqual(L([1,2,3])[:2], [1,2])\r
- self.assertEqual(L([1,2,3])[slice(2)], [1,2])\r
- self.assertEqual(L([1,2,3]).__getitem__(slice(2)), [1,2])\r
- # Now do lists and __setitem__\r
- a = L([1,2,3])\r
- a[slice(1, 3)] = [3,2]\r
- self.assertEqual(a, [1,3,2])\r
- a[slice(0, 2, 1)] = [3,1]\r
- self.assertEqual(a, [3,1,2])\r
- a.__setitem__(slice(1, 3), [2,1])\r
- self.assertEqual(a, [3,2,1])\r
- a.__setitem__(slice(0, 2, 1), [2,3])\r
- self.assertEqual(a, [2,3,1])\r
-\r
- def test_subtype_resurrection(self):\r
- # Testing resurrection of new-style instance...\r
-\r
- class C(object):\r
- container = []\r
-\r
- def __del__(self):\r
- # resurrect the instance\r
- C.container.append(self)\r
-\r
- c = C()\r
- c.attr = 42\r
-\r
- # The most interesting thing here is whether this blows up, due to\r
- # flawed GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1\r
- # bug).\r
- del c\r
-\r
- # If that didn't blow up, it's also interesting to see whether clearing\r
- # the last container slot works: that will attempt to delete c again,\r
- # which will cause c to get appended back to the container again\r
- # "during" the del. (On non-CPython implementations, however, __del__\r
- # is typically not called again.)\r
- test_support.gc_collect()\r
- self.assertEqual(len(C.container), 1)\r
- del C.container[-1]\r
- if test_support.check_impl_detail():\r
- test_support.gc_collect()\r
- self.assertEqual(len(C.container), 1)\r
- self.assertEqual(C.container[-1].attr, 42)\r
-\r
- # Make c mortal again, so that the test framework with -l doesn't report\r
- # it as a leak.\r
- del C.__del__\r
-\r
- def test_slots_trash(self):\r
- # Testing slot trash...\r
- # Deallocating deeply nested slotted trash caused stack overflows\r
- class trash(object):\r
- __slots__ = ['x']\r
- def __init__(self, x):\r
- self.x = x\r
- o = None\r
- for i in xrange(50000):\r
- o = trash(o)\r
- del o\r
-\r
- def test_slots_multiple_inheritance(self):\r
- # SF bug 575229, multiple inheritance w/ slots dumps core\r
- class A(object):\r
- __slots__=()\r
- class B(object):\r
- pass\r
- class C(A,B) :\r
- __slots__=()\r
- if test_support.check_impl_detail():\r
- self.assertEqual(C.__basicsize__, B.__basicsize__)\r
- self.assertTrue(hasattr(C, '__dict__'))\r
- self.assertTrue(hasattr(C, '__weakref__'))\r
- C().x = 2\r
-\r
- def test_rmul(self):\r
- # Testing correct invocation of __rmul__...\r
- # SF patch 592646\r
- class C(object):\r
- def __mul__(self, other):\r
- return "mul"\r
- def __rmul__(self, other):\r
- return "rmul"\r
- a = C()\r
- self.assertEqual(a*2, "mul")\r
- self.assertEqual(a*2.2, "mul")\r
- self.assertEqual(2*a, "rmul")\r
- self.assertEqual(2.2*a, "rmul")\r
-\r
- def test_ipow(self):\r
- # Testing correct invocation of __ipow__...\r
- # [SF bug 620179]\r
- class C(object):\r
- def __ipow__(self, other):\r
- pass\r
- a = C()\r
- a **= 2\r
-\r
- def test_mutable_bases(self):\r
- # Testing mutable bases...\r
-\r
- # stuff that should work:\r
- class C(object):\r
- pass\r
- class C2(object):\r
- def __getattribute__(self, attr):\r
- if attr == 'a':\r
- return 2\r
- else:\r
- return super(C2, self).__getattribute__(attr)\r
- def meth(self):\r
- return 1\r
- class D(C):\r
- pass\r
- class E(D):\r
- pass\r
- d = D()\r
- e = E()\r
- D.__bases__ = (C,)\r
- D.__bases__ = (C2,)\r
- self.assertEqual(d.meth(), 1)\r
- self.assertEqual(e.meth(), 1)\r
- self.assertEqual(d.a, 2)\r
- self.assertEqual(e.a, 2)\r
- self.assertEqual(C2.__subclasses__(), [D])\r
-\r
- try:\r
- del D.__bases__\r
- except (TypeError, AttributeError):\r
- pass\r
- else:\r
- self.fail("shouldn't be able to delete .__bases__")\r
-\r
- try:\r
- D.__bases__ = ()\r
- except TypeError, msg:\r
- if str(msg) == "a new-style class can't have only classic bases":\r
- self.fail("wrong error message for .__bases__ = ()")\r
- else:\r
- self.fail("shouldn't be able to set .__bases__ to ()")\r
-\r
- try:\r
- D.__bases__ = (D,)\r
- except TypeError:\r
- pass\r
- else:\r
- # actually, we'll have crashed by here...\r
- self.fail("shouldn't be able to create inheritance cycles")\r
-\r
- try:\r
- D.__bases__ = (C, C)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("didn't detect repeated base classes")\r
-\r
- try:\r
- D.__bases__ = (E,)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't be able to create inheritance cycles")\r
-\r
- # let's throw a classic class into the mix:\r
- class Classic:\r
- def meth2(self):\r
- return 3\r
-\r
- D.__bases__ = (C, Classic)\r
-\r
- self.assertEqual(d.meth2(), 3)\r
- self.assertEqual(e.meth2(), 3)\r
- try:\r
- d.a\r
- except AttributeError:\r
- pass\r
- else:\r
- self.fail("attribute should have vanished")\r
-\r
- try:\r
- D.__bases__ = (Classic,)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("new-style class must have a new-style base")\r
-\r
- def test_builtin_bases(self):\r
- # Make sure all the builtin types can have their base queried without\r
- # segfaulting. See issue #5787.\r
- builtin_types = [tp for tp in __builtin__.__dict__.itervalues()\r
- if isinstance(tp, type)]\r
- for tp in builtin_types:\r
- object.__getattribute__(tp, "__bases__")\r
- if tp is not object:\r
- self.assertEqual(len(tp.__bases__), 1, tp)\r
-\r
- class L(list):\r
- pass\r
-\r
- class C(object):\r
- pass\r
-\r
- class D(C):\r
- pass\r
-\r
- try:\r
- L.__bases__ = (dict,)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't turn list subclass into dict subclass")\r
-\r
- try:\r
- list.__bases__ = (dict,)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't be able to assign to list.__bases__")\r
-\r
- try:\r
- D.__bases__ = (C, list)\r
- except TypeError:\r
- pass\r
- else:\r
- assert 0, "best_base calculation found wanting"\r
-\r
-\r
- def test_mutable_bases_with_failing_mro(self):\r
- # Testing mutable bases with failing mro...\r
- class WorkOnce(type):\r
- def __new__(self, name, bases, ns):\r
- self.flag = 0\r
- return super(WorkOnce, self).__new__(WorkOnce, name, bases, ns)\r
- def mro(self):\r
- if self.flag > 0:\r
- raise RuntimeError, "bozo"\r
- else:\r
- self.flag += 1\r
- return type.mro(self)\r
-\r
- class WorkAlways(type):\r
- def mro(self):\r
- # this is here to make sure that .mro()s aren't called\r
- # with an exception set (which was possible at one point).\r
- # An error message will be printed in a debug build.\r
- # What's a good way to test for this?\r
- return type.mro(self)\r
-\r
- class C(object):\r
- pass\r
-\r
- class C2(object):\r
- pass\r
-\r
- class D(C):\r
- pass\r
-\r
- class E(D):\r
- pass\r
-\r
- class F(D):\r
- __metaclass__ = WorkOnce\r
-\r
- class G(D):\r
- __metaclass__ = WorkAlways\r
-\r
- # Immediate subclasses have their mro's adjusted in alphabetical\r
- # order, so E's will get adjusted before adjusting F's fails. We\r
- # check here that E's gets restored.\r
-\r
- E_mro_before = E.__mro__\r
- D_mro_before = D.__mro__\r
-\r
- try:\r
- D.__bases__ = (C2,)\r
- except RuntimeError:\r
- self.assertEqual(E.__mro__, E_mro_before)\r
- self.assertEqual(D.__mro__, D_mro_before)\r
- else:\r
- self.fail("exception not propagated")\r
-\r
- def test_mutable_bases_catch_mro_conflict(self):\r
- # Testing mutable bases catch mro conflict...\r
- class A(object):\r
- pass\r
-\r
- class B(object):\r
- pass\r
-\r
- class C(A, B):\r
- pass\r
-\r
- class D(A, B):\r
- pass\r
-\r
- class E(C, D):\r
- pass\r
-\r
- try:\r
- C.__bases__ = (B, A)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("didn't catch MRO conflict")\r
-\r
- def test_mutable_names(self):\r
- # Testing mutable names...\r
- class C(object):\r
- pass\r
-\r
- # C.__module__ could be 'test_descr' or '__main__'\r
- mod = C.__module__\r
-\r
- C.__name__ = 'D'\r
- self.assertEqual((C.__module__, C.__name__), (mod, 'D'))\r
-\r
- C.__name__ = 'D.E'\r
- self.assertEqual((C.__module__, C.__name__), (mod, 'D.E'))\r
-\r
- def test_subclass_right_op(self):\r
- # Testing correct dispatch of subclass overloading __r<op>__...\r
-\r
- # This code tests various cases where right-dispatch of a subclass\r
- # should be preferred over left-dispatch of a base class.\r
-\r
- # Case 1: subclass of int; this tests code in abstract.c::binary_op1()\r
-\r
- class B(int):\r
- def __floordiv__(self, other):\r
- return "B.__floordiv__"\r
- def __rfloordiv__(self, other):\r
- return "B.__rfloordiv__"\r
-\r
- self.assertEqual(B(1) // 1, "B.__floordiv__")\r
- self.assertEqual(1 // B(1), "B.__rfloordiv__")\r
-\r
- # Case 2: subclass of object; this is just the baseline for case 3\r
-\r
- class C(object):\r
- def __floordiv__(self, other):\r
- return "C.__floordiv__"\r
- def __rfloordiv__(self, other):\r
- return "C.__rfloordiv__"\r
-\r
- self.assertEqual(C() // 1, "C.__floordiv__")\r
- self.assertEqual(1 // C(), "C.__rfloordiv__")\r
-\r
- # Case 3: subclass of new-style class; here it gets interesting\r
-\r
- class D(C):\r
- def __floordiv__(self, other):\r
- return "D.__floordiv__"\r
- def __rfloordiv__(self, other):\r
- return "D.__rfloordiv__"\r
-\r
- self.assertEqual(D() // C(), "D.__floordiv__")\r
- self.assertEqual(C() // D(), "D.__rfloordiv__")\r
-\r
- # Case 4: this didn't work right in 2.2.2 and 2.3a1\r
-\r
- class E(C):\r
- pass\r
-\r
- self.assertEqual(E.__rfloordiv__, C.__rfloordiv__)\r
-\r
- self.assertEqual(E() // 1, "C.__floordiv__")\r
- self.assertEqual(1 // E(), "C.__rfloordiv__")\r
- self.assertEqual(E() // C(), "C.__floordiv__")\r
- self.assertEqual(C() // E(), "C.__floordiv__") # This one would fail\r
-\r
- @test_support.impl_detail("testing an internal kind of method object")\r
- def test_meth_class_get(self):\r
- # Testing __get__ method of METH_CLASS C methods...\r
- # Full coverage of descrobject.c::classmethod_get()\r
-\r
- # Baseline\r
- arg = [1, 2, 3]\r
- res = {1: None, 2: None, 3: None}\r
- self.assertEqual(dict.fromkeys(arg), res)\r
- self.assertEqual({}.fromkeys(arg), res)\r
-\r
- # Now get the descriptor\r
- descr = dict.__dict__["fromkeys"]\r
-\r
- # More baseline using the descriptor directly\r
- self.assertEqual(descr.__get__(None, dict)(arg), res)\r
- self.assertEqual(descr.__get__({})(arg), res)\r
-\r
- # Now check various error cases\r
- try:\r
- descr.__get__(None, None)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't have allowed descr.__get__(None, None)")\r
- try:\r
- descr.__get__(42)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't have allowed descr.__get__(42)")\r
- try:\r
- descr.__get__(None, 42)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't have allowed descr.__get__(None, 42)")\r
- try:\r
- descr.__get__(None, int)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("shouldn't have allowed descr.__get__(None, int)")\r
-\r
- def test_isinst_isclass(self):\r
- # Testing proxy isinstance() and isclass()...\r
- class Proxy(object):\r
- def __init__(self, obj):\r
- self.__obj = obj\r
- def __getattribute__(self, name):\r
- if name.startswith("_Proxy__"):\r
- return object.__getattribute__(self, name)\r
- else:\r
- return getattr(self.__obj, name)\r
- # Test with a classic class\r
- class C:\r
- pass\r
- a = C()\r
- pa = Proxy(a)\r
- self.assertIsInstance(a, C) # Baseline\r
- self.assertIsInstance(pa, C) # Test\r
- # Test with a classic subclass\r
- class D(C):\r
- pass\r
- a = D()\r
- pa = Proxy(a)\r
- self.assertIsInstance(a, C) # Baseline\r
- self.assertIsInstance(pa, C) # Test\r
- # Test with a new-style class\r
- class C(object):\r
- pass\r
- a = C()\r
- pa = Proxy(a)\r
- self.assertIsInstance(a, C) # Baseline\r
- self.assertIsInstance(pa, C) # Test\r
- # Test with a new-style subclass\r
- class D(C):\r
- pass\r
- a = D()\r
- pa = Proxy(a)\r
- self.assertIsInstance(a, C) # Baseline\r
- self.assertIsInstance(pa, C) # Test\r
-\r
- def test_proxy_super(self):\r
- # Testing super() for a proxy object...\r
- class Proxy(object):\r
- def __init__(self, obj):\r
- self.__obj = obj\r
- def __getattribute__(self, name):\r
- if name.startswith("_Proxy__"):\r
- return object.__getattribute__(self, name)\r
- else:\r
- return getattr(self.__obj, name)\r
-\r
- class B(object):\r
- def f(self):\r
- return "B.f"\r
-\r
- class C(B):\r
- def f(self):\r
- return super(C, self).f() + "->C.f"\r
-\r
- obj = C()\r
- p = Proxy(obj)\r
- self.assertEqual(C.__dict__["f"](p), "B.f->C.f")\r
-\r
- def test_carloverre(self):\r
- # Testing prohibition of Carlo Verre's hack...\r
- try:\r
- object.__setattr__(str, "foo", 42)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("Carlo Verre __setattr__ succeeded!")\r
- try:\r
- object.__delattr__(str, "lower")\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("Carlo Verre __delattr__ succeeded!")\r
-\r
- def test_weakref_segfault(self):\r
- # Testing weakref segfault...\r
- # SF 742911\r
- import weakref\r
-\r
- class Provoker:\r
- def __init__(self, referrent):\r
- self.ref = weakref.ref(referrent)\r
-\r
- def __del__(self):\r
- x = self.ref()\r
-\r
- class Oops(object):\r
- pass\r
-\r
- o = Oops()\r
- o.whatever = Provoker(o)\r
- del o\r
-\r
- def test_wrapper_segfault(self):\r
- # SF 927248: deeply nested wrappers could cause stack overflow\r
- f = lambda:None\r
- for i in xrange(1000000):\r
- f = f.__call__\r
- f = None\r
-\r
- def test_file_fault(self):\r
- # Testing sys.stdout is changed in getattr...\r
- test_stdout = sys.stdout\r
- class StdoutGuard:\r
- def __getattr__(self, attr):\r
- sys.stdout = sys.__stdout__\r
- raise RuntimeError("Premature access to sys.stdout.%s" % attr)\r
- sys.stdout = StdoutGuard()\r
- try:\r
- print "Oops!"\r
- except RuntimeError:\r
- pass\r
- finally:\r
- sys.stdout = test_stdout\r
-\r
- def test_vicious_descriptor_nonsense(self):\r
- # Testing vicious_descriptor_nonsense...\r
-\r
- # A potential segfault spotted by Thomas Wouters in mail to\r
- # python-dev 2003-04-17, turned into an example & fixed by Michael\r
- # Hudson just less than four months later...\r
-\r
- class Evil(object):\r
- def __hash__(self):\r
- return hash('attr')\r
- def __eq__(self, other):\r
- del C.attr\r
- return 0\r
-\r
- class Descr(object):\r
- def __get__(self, ob, type=None):\r
- return 1\r
-\r
- class C(object):\r
- attr = Descr()\r
-\r
- c = C()\r
- c.__dict__[Evil()] = 0\r
-\r
- self.assertEqual(c.attr, 1)\r
- # this makes a crash more likely:\r
- test_support.gc_collect()\r
- self.assertEqual(hasattr(c, 'attr'), False)\r
-\r
- def test_init(self):\r
- # SF 1155938\r
- class Foo(object):\r
- def __init__(self):\r
- return 10\r
- try:\r
- Foo()\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("did not test __init__() for None return")\r
-\r
- def test_method_wrapper(self):\r
- # Testing method-wrapper objects...\r
- # <type 'method-wrapper'> did not support any reflection before 2.5\r
-\r
- l = []\r
- self.assertEqual(l.__add__, l.__add__)\r
- self.assertEqual(l.__add__, [].__add__)\r
- self.assertTrue(l.__add__ != [5].__add__)\r
- self.assertTrue(l.__add__ != l.__mul__)\r
- self.assertTrue(l.__add__.__name__ == '__add__')\r
- if hasattr(l.__add__, '__self__'):\r
- # CPython\r
- self.assertTrue(l.__add__.__self__ is l)\r
- self.assertTrue(l.__add__.__objclass__ is list)\r
- else:\r
- # Python implementations where [].__add__ is a normal bound method\r
- self.assertTrue(l.__add__.im_self is l)\r
- self.assertTrue(l.__add__.im_class is list)\r
- self.assertEqual(l.__add__.__doc__, list.__add__.__doc__)\r
- try:\r
- hash(l.__add__)\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("no TypeError from hash([].__add__)")\r
-\r
- t = ()\r
- t += (7,)\r
- self.assertEqual(t.__add__, (7,).__add__)\r
- self.assertEqual(hash(t.__add__), hash((7,).__add__))\r
-\r
- def test_not_implemented(self):\r
- # Testing NotImplemented...\r
- # all binary methods should be able to return a NotImplemented\r
- import operator\r
-\r
- def specialmethod(self, other):\r
- return NotImplemented\r
-\r
- def check(expr, x, y):\r
- try:\r
- exec expr in {'x': x, 'y': y, 'operator': operator}\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("no TypeError from %r" % (expr,))\r
-\r
- N1 = sys.maxint + 1L # might trigger OverflowErrors instead of\r
- # TypeErrors\r
- N2 = sys.maxint # if sizeof(int) < sizeof(long), might trigger\r
- # ValueErrors instead of TypeErrors\r
- for metaclass in [type, types.ClassType]:\r
- for name, expr, iexpr in [\r
- ('__add__', 'x + y', 'x += y'),\r
- ('__sub__', 'x - y', 'x -= y'),\r
- ('__mul__', 'x * y', 'x *= y'),\r
- ('__truediv__', 'operator.truediv(x, y)', None),\r
- ('__floordiv__', 'operator.floordiv(x, y)', None),\r
- ('__div__', 'x / y', 'x /= y'),\r
- ('__mod__', 'x % y', 'x %= y'),\r
- ('__divmod__', 'divmod(x, y)', None),\r
- ('__pow__', 'x ** y', 'x **= y'),\r
- ('__lshift__', 'x << y', 'x <<= y'),\r
- ('__rshift__', 'x >> y', 'x >>= y'),\r
- ('__and__', 'x & y', 'x &= y'),\r
- ('__or__', 'x | y', 'x |= y'),\r
- ('__xor__', 'x ^ y', 'x ^= y'),\r
- ('__coerce__', 'coerce(x, y)', None)]:\r
- if name == '__coerce__':\r
- rname = name\r
- else:\r
- rname = '__r' + name[2:]\r
- A = metaclass('A', (), {name: specialmethod})\r
- B = metaclass('B', (), {rname: specialmethod})\r
- a = A()\r
- b = B()\r
- check(expr, a, a)\r
- check(expr, a, b)\r
- check(expr, b, a)\r
- check(expr, b, b)\r
- check(expr, a, N1)\r
- check(expr, a, N2)\r
- check(expr, N1, b)\r
- check(expr, N2, b)\r
- if iexpr:\r
- check(iexpr, a, a)\r
- check(iexpr, a, b)\r
- check(iexpr, b, a)\r
- check(iexpr, b, b)\r
- check(iexpr, a, N1)\r
- check(iexpr, a, N2)\r
- iname = '__i' + name[2:]\r
- C = metaclass('C', (), {iname: specialmethod})\r
- c = C()\r
- check(iexpr, c, a)\r
- check(iexpr, c, b)\r
- check(iexpr, c, N1)\r
- check(iexpr, c, N2)\r
-\r
- def test_assign_slice(self):\r
- # ceval.c's assign_slice used to check for\r
- # tp->tp_as_sequence->sq_slice instead of\r
- # tp->tp_as_sequence->sq_ass_slice\r
-\r
- class C(object):\r
- def __setslice__(self, start, stop, value):\r
- self.value = value\r
-\r
- c = C()\r
- c[1:2] = 3\r
- self.assertEqual(c.value, 3)\r
-\r
- def test_set_and_no_get(self):\r
- # See\r
- # http://mail.python.org/pipermail/python-dev/2010-January/095637.html\r
- class Descr(object):\r
-\r
- def __init__(self, name):\r
- self.name = name\r
-\r
- def __set__(self, obj, value):\r
- obj.__dict__[self.name] = value\r
- descr = Descr("a")\r
-\r
- class X(object):\r
- a = descr\r
-\r
- x = X()\r
- self.assertIs(x.a, descr)\r
- x.a = 42\r
- self.assertEqual(x.a, 42)\r
-\r
- # Also check type_getattro for correctness.\r
- class Meta(type):\r
- pass\r
- class X(object):\r
- __metaclass__ = Meta\r
- X.a = 42\r
- Meta.a = Descr("a")\r
- self.assertEqual(X.a, 42)\r
-\r
- def test_getattr_hooks(self):\r
- # issue 4230\r
-\r
- class Descriptor(object):\r
- counter = 0\r
- def __get__(self, obj, objtype=None):\r
- def getter(name):\r
- self.counter += 1\r
- raise AttributeError(name)\r
- return getter\r
-\r
- descr = Descriptor()\r
- class A(object):\r
- __getattribute__ = descr\r
- class B(object):\r
- __getattr__ = descr\r
- class C(object):\r
- __getattribute__ = descr\r
- __getattr__ = descr\r
-\r
- self.assertRaises(AttributeError, getattr, A(), "attr")\r
- self.assertEqual(descr.counter, 1)\r
- self.assertRaises(AttributeError, getattr, B(), "attr")\r
- self.assertEqual(descr.counter, 2)\r
- self.assertRaises(AttributeError, getattr, C(), "attr")\r
- self.assertEqual(descr.counter, 4)\r
-\r
- import gc\r
- class EvilGetattribute(object):\r
- # This used to segfault\r
- def __getattr__(self, name):\r
- raise AttributeError(name)\r
- def __getattribute__(self, name):\r
- del EvilGetattribute.__getattr__\r
- for i in range(5):\r
- gc.collect()\r
- raise AttributeError(name)\r
-\r
- self.assertRaises(AttributeError, getattr, EvilGetattribute(), "attr")\r
-\r
- def test_abstractmethods(self):\r
- # type pretends not to have __abstractmethods__.\r
- self.assertRaises(AttributeError, getattr, type, "__abstractmethods__")\r
- class meta(type):\r
- pass\r
- self.assertRaises(AttributeError, getattr, meta, "__abstractmethods__")\r
- class X(object):\r
- pass\r
- with self.assertRaises(AttributeError):\r
- del X.__abstractmethods__\r
-\r
- def test_proxy_call(self):\r
- class FakeStr(object):\r
- __class__ = str\r
-\r
- fake_str = FakeStr()\r
- # isinstance() reads __class__ on new style classes\r
- self.assertTrue(isinstance(fake_str, str))\r
-\r
- # call a method descriptor\r
- with self.assertRaises(TypeError):\r
- str.split(fake_str)\r
-\r
- # call a slot wrapper descriptor\r
- with self.assertRaises(TypeError):\r
- str.__add__(fake_str, "abc")\r
-\r
-\r
-class DictProxyTests(unittest.TestCase):\r
- def setUp(self):\r
- class C(object):\r
- def meth(self):\r
- pass\r
- self.C = C\r
-\r
- def test_iter_keys(self):\r
- # Testing dict-proxy iterkeys...\r
- keys = [ key for key in self.C.__dict__.iterkeys() ]\r
- keys.sort()\r
- self.assertEqual(keys, ['__dict__', '__doc__', '__module__',\r
- '__weakref__', 'meth'])\r
-\r
- def test_iter_values(self):\r
- # Testing dict-proxy itervalues...\r
- values = [ values for values in self.C.__dict__.itervalues() ]\r
- self.assertEqual(len(values), 5)\r
-\r
- def test_iter_items(self):\r
- # Testing dict-proxy iteritems...\r
- keys = [ key for (key, value) in self.C.__dict__.iteritems() ]\r
- keys.sort()\r
- self.assertEqual(keys, ['__dict__', '__doc__', '__module__',\r
- '__weakref__', 'meth'])\r
-\r
- def test_dict_type_with_metaclass(self):\r
- # Testing type of __dict__ when __metaclass__ set...\r
- class B(object):\r
- pass\r
- class M(type):\r
- pass\r
- class C:\r
- # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy\r
- __metaclass__ = M\r
- self.assertEqual(type(C.__dict__), type(B.__dict__))\r
-\r
-\r
-class PTypesLongInitTest(unittest.TestCase):\r
- # This is in its own TestCase so that it can be run before any other tests.\r
- def test_pytype_long_ready(self):\r
- # Testing SF bug 551412 ...\r
-\r
- # This dumps core when SF bug 551412 isn't fixed --\r
- # but only when test_descr.py is run separately.\r
- # (That can't be helped -- as soon as PyType_Ready()\r
- # is called for PyLong_Type, the bug is gone.)\r
- class UserLong(object):\r
- def __pow__(self, *args):\r
- pass\r
- try:\r
- pow(0L, UserLong(), 0L)\r
- except:\r
- pass\r
-\r
- # Another segfault only when run early\r
- # (before PyType_Ready(tuple) is called)\r
- type.mro(tuple)\r
-\r
-\r
-def test_main():\r
- deprecations = [(r'complex divmod\(\), // and % are deprecated$',\r
- DeprecationWarning)]\r
- if sys.py3kwarning:\r
- deprecations += [\r
- ("classic (int|long) division", DeprecationWarning),\r
- ("coerce.. not supported", DeprecationWarning),\r
- (".+__(get|set|del)slice__ has been removed", DeprecationWarning)]\r
- with test_support.check_warnings(*deprecations):\r
- # Run all local test cases, with PTypesLongInitTest first.\r
- test_support.run_unittest(PTypesLongInitTest, OperatorsTest,\r
- ClassPropertiesAndMethods, DictProxyTests)\r
-\r
-if __name__ == "__main__":\r
- test_main()\r
projects / mirror_edk2.git / blobdiff