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