diff options
Diffstat (limited to 'lib/python2.7/test/test_copy.py')
| -rw-r--r-- | lib/python2.7/test/test_copy.py | 712 |
1 files changed, 0 insertions, 712 deletions
diff --git a/lib/python2.7/test/test_copy.py b/lib/python2.7/test/test_copy.py deleted file mode 100644 index 6b64f10..0000000 --- a/lib/python2.7/test/test_copy.py +++ /dev/null @@ -1,712 +0,0 @@ -"""Unit tests for the copy module.""" - -import copy -import copy_reg -import weakref - -import unittest -from test import test_support - -class TestCopy(unittest.TestCase): - - # Attempt full line coverage of copy.py from top to bottom - - def test_exceptions(self): - self.assertTrue(copy.Error is copy.error) - self.assertTrue(issubclass(copy.Error, Exception)) - - # The copy() method - - def test_copy_basic(self): - x = 42 - y = copy.copy(x) - self.assertEqual(x, y) - - def test_copy_copy(self): - class C(object): - def __init__(self, foo): - self.foo = foo - def __copy__(self): - return C(self.foo) - x = C(42) - y = copy.copy(x) - self.assertEqual(y.__class__, x.__class__) - self.assertEqual(y.foo, x.foo) - - def test_copy_registry(self): - class C(object): - def __new__(cls, foo): - obj = object.__new__(cls) - obj.foo = foo - return obj - def pickle_C(obj): - return (C, (obj.foo,)) - x = C(42) - self.assertRaises(TypeError, copy.copy, x) - copy_reg.pickle(C, pickle_C, C) - y = copy.copy(x) - - def test_copy_reduce_ex(self): - class C(object): - def __reduce_ex__(self, proto): - return "" - def __reduce__(self): - raise test_support.TestFailed, "shouldn't call this" - x = C() - y = copy.copy(x) - self.assertTrue(y is x) - - def test_copy_reduce(self): - class C(object): - def __reduce__(self): - return "" - x = C() - y = copy.copy(x) - self.assertTrue(y is x) - - def test_copy_cant(self): - class C(object): - def __getattribute__(self, name): - if name.startswith("__reduce"): - raise AttributeError, name - return object.__getattribute__(self, name) - x = C() - self.assertRaises(copy.Error, copy.copy, x) - - # Type-specific _copy_xxx() methods - - def test_copy_atomic(self): - class Classic: - pass - class NewStyle(object): - pass - def f(): - pass - tests = [None, 42, 2L**100, 3.14, True, False, 1j, - "hello", u"hello\u1234", f.func_code, - NewStyle, xrange(10), Classic, max] - for x in tests: - self.assertTrue(copy.copy(x) is x, repr(x)) - - def test_copy_list(self): - x = [1, 2, 3] - self.assertEqual(copy.copy(x), x) - - def test_copy_tuple(self): - x = (1, 2, 3) - self.assertEqual(copy.copy(x), x) - - def test_copy_dict(self): - x = {"foo": 1, "bar": 2} - self.assertEqual(copy.copy(x), x) - - def test_copy_inst_vanilla(self): - class C: - def __init__(self, foo): - self.foo = foo - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C(42) - self.assertEqual(copy.copy(x), x) - - def test_copy_inst_copy(self): - class C: - def __init__(self, foo): - self.foo = foo - def __copy__(self): - return C(self.foo) - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C(42) - self.assertEqual(copy.copy(x), x) - - def test_copy_inst_getinitargs(self): - class C: - def __init__(self, foo): - self.foo = foo - def __getinitargs__(self): - return (self.foo,) - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C(42) - self.assertEqual(copy.copy(x), x) - - def test_copy_inst_getstate(self): - class C: - def __init__(self, foo): - self.foo = foo - def __getstate__(self): - return {"foo": self.foo} - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C(42) - self.assertEqual(copy.copy(x), x) - - def test_copy_inst_setstate(self): - class C: - def __init__(self, foo): - self.foo = foo - def __setstate__(self, state): - self.foo = state["foo"] - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C(42) - self.assertEqual(copy.copy(x), x) - - def test_copy_inst_getstate_setstate(self): - class C: - def __init__(self, foo): - self.foo = foo - def __getstate__(self): - return self.foo - def __setstate__(self, state): - self.foo = state - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C(42) - self.assertEqual(copy.copy(x), x) - - # The deepcopy() method - - def test_deepcopy_basic(self): - x = 42 - y = copy.deepcopy(x) - self.assertEqual(y, x) - - def test_deepcopy_memo(self): - # Tests of reflexive objects are under type-specific sections below. - # This tests only repetitions of objects. - x = [] - x = [x, x] - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y is not x) - self.assertTrue(y[0] is not x[0]) - self.assertTrue(y[0] is y[1]) - - def test_deepcopy_issubclass(self): - # XXX Note: there's no way to test the TypeError coming out of - # issubclass() -- this can only happen when an extension - # module defines a "type" that doesn't formally inherit from - # type. - class Meta(type): - pass - class C: - __metaclass__ = Meta - self.assertEqual(copy.deepcopy(C), C) - - def test_deepcopy_deepcopy(self): - class C(object): - def __init__(self, foo): - self.foo = foo - def __deepcopy__(self, memo=None): - return C(self.foo) - x = C(42) - y = copy.deepcopy(x) - self.assertEqual(y.__class__, x.__class__) - self.assertEqual(y.foo, x.foo) - - def test_deepcopy_registry(self): - class C(object): - def __new__(cls, foo): - obj = object.__new__(cls) - obj.foo = foo - return obj - def pickle_C(obj): - return (C, (obj.foo,)) - x = C(42) - self.assertRaises(TypeError, copy.deepcopy, x) - copy_reg.pickle(C, pickle_C, C) - y = copy.deepcopy(x) - - def test_deepcopy_reduce_ex(self): - class C(object): - def __reduce_ex__(self, proto): - return "" - def __reduce__(self): - raise test_support.TestFailed, "shouldn't call this" - x = C() - y = copy.deepcopy(x) - self.assertTrue(y is x) - - def test_deepcopy_reduce(self): - class C(object): - def __reduce__(self): - return "" - x = C() - y = copy.deepcopy(x) - self.assertTrue(y is x) - - def test_deepcopy_cant(self): - class C(object): - def __getattribute__(self, name): - if name.startswith("__reduce"): - raise AttributeError, name - return object.__getattribute__(self, name) - x = C() - self.assertRaises(copy.Error, copy.deepcopy, x) - - # Type-specific _deepcopy_xxx() methods - - def test_deepcopy_atomic(self): - class Classic: - pass - class NewStyle(object): - pass - def f(): - pass - tests = [None, 42, 2L**100, 3.14, True, False, 1j, - "hello", u"hello\u1234", f.func_code, - NewStyle, xrange(10), Classic, max] - for x in tests: - self.assertTrue(copy.deepcopy(x) is x, repr(x)) - - def test_deepcopy_list(self): - x = [[1, 2], 3] - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(x is not y) - self.assertTrue(x[0] is not y[0]) - - def test_deepcopy_reflexive_list(self): - x = [] - x.append(x) - y = copy.deepcopy(x) - self.assertRaises(RuntimeError, cmp, y, x) - self.assertTrue(y is not x) - self.assertTrue(y[0] is y) - self.assertEqual(len(y), 1) - - def test_deepcopy_tuple(self): - x = ([1, 2], 3) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(x is not y) - self.assertTrue(x[0] is not y[0]) - - def test_deepcopy_reflexive_tuple(self): - x = ([],) - x[0].append(x) - y = copy.deepcopy(x) - self.assertRaises(RuntimeError, cmp, y, x) - self.assertTrue(y is not x) - self.assertTrue(y[0] is not x[0]) - self.assertTrue(y[0][0] is y) - - def test_deepcopy_dict(self): - x = {"foo": [1, 2], "bar": 3} - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(x is not y) - self.assertTrue(x["foo"] is not y["foo"]) - - def test_deepcopy_reflexive_dict(self): - x = {} - x['foo'] = x - y = copy.deepcopy(x) - self.assertRaises(RuntimeError, cmp, y, x) - self.assertTrue(y is not x) - self.assertTrue(y['foo'] is y) - self.assertEqual(len(y), 1) - - def test_deepcopy_keepalive(self): - memo = {} - x = 42 - y = copy.deepcopy(x, memo) - self.assertTrue(memo[id(x)] is x) - - def test_deepcopy_inst_vanilla(self): - class C: - def __init__(self, foo): - self.foo = foo - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C([42]) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y.foo is not x.foo) - - def test_deepcopy_inst_deepcopy(self): - class C: - def __init__(self, foo): - self.foo = foo - def __deepcopy__(self, memo): - return C(copy.deepcopy(self.foo, memo)) - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C([42]) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is not x.foo) - - def test_deepcopy_inst_getinitargs(self): - class C: - def __init__(self, foo): - self.foo = foo - def __getinitargs__(self): - return (self.foo,) - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C([42]) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is not x.foo) - - def test_deepcopy_inst_getstate(self): - class C: - def __init__(self, foo): - self.foo = foo - def __getstate__(self): - return {"foo": self.foo} - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C([42]) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is not x.foo) - - def test_deepcopy_inst_setstate(self): - class C: - def __init__(self, foo): - self.foo = foo - def __setstate__(self, state): - self.foo = state["foo"] - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C([42]) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is not x.foo) - - def test_deepcopy_inst_getstate_setstate(self): - class C: - def __init__(self, foo): - self.foo = foo - def __getstate__(self): - return self.foo - def __setstate__(self, state): - self.foo = state - def __cmp__(self, other): - return cmp(self.foo, other.foo) - x = C([42]) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is not x.foo) - - def test_deepcopy_reflexive_inst(self): - class C: - pass - x = C() - x.foo = x - y = copy.deepcopy(x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is y) - - # _reconstruct() - - def test_reconstruct_string(self): - class C(object): - def __reduce__(self): - return "" - x = C() - y = copy.copy(x) - self.assertTrue(y is x) - y = copy.deepcopy(x) - self.assertTrue(y is x) - - def test_reconstruct_nostate(self): - class C(object): - def __reduce__(self): - return (C, ()) - x = C() - x.foo = 42 - y = copy.copy(x) - self.assertTrue(y.__class__ is x.__class__) - y = copy.deepcopy(x) - self.assertTrue(y.__class__ is x.__class__) - - def test_reconstruct_state(self): - class C(object): - def __reduce__(self): - return (C, (), self.__dict__) - def __cmp__(self, other): - return cmp(self.__dict__, other.__dict__) - __hash__ = None # Silence Py3k warning - x = C() - x.foo = [42] - y = copy.copy(x) - self.assertEqual(y, x) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y.foo is not x.foo) - - def test_reconstruct_state_setstate(self): - class C(object): - def __reduce__(self): - return (C, (), self.__dict__) - def __setstate__(self, state): - self.__dict__.update(state) - def __cmp__(self, other): - return cmp(self.__dict__, other.__dict__) - __hash__ = None # Silence Py3k warning - x = C() - x.foo = [42] - y = copy.copy(x) - self.assertEqual(y, x) - y = copy.deepcopy(x) - self.assertEqual(y, x) - self.assertTrue(y.foo is not x.foo) - - def test_reconstruct_reflexive(self): - class C(object): - pass - x = C() - x.foo = x - y = copy.deepcopy(x) - self.assertTrue(y is not x) - self.assertTrue(y.foo is y) - - # Additions for Python 2.3 and pickle protocol 2 - - def test_reduce_4tuple(self): - class C(list): - def __reduce__(self): - return (C, (), self.__dict__, iter(self)) - def __cmp__(self, other): - return (cmp(list(self), list(other)) or - cmp(self.__dict__, other.__dict__)) - __hash__ = None # Silence Py3k warning - x = C([[1, 2], 3]) - y = copy.copy(x) - self.assertEqual(x, y) - self.assertTrue(x is not y) - self.assertTrue(x[0] is y[0]) - y = copy.deepcopy(x) - self.assertEqual(x, y) - self.assertTrue(x is not y) - self.assertTrue(x[0] is not y[0]) - - def test_reduce_5tuple(self): - class C(dict): - def __reduce__(self): - return (C, (), self.__dict__, None, self.iteritems()) - def __cmp__(self, other): - return (cmp(dict(self), list(dict)) or - cmp(self.__dict__, other.__dict__)) - __hash__ = None # Silence Py3k warning - x = C([("foo", [1, 2]), ("bar", 3)]) - y = copy.copy(x) - self.assertEqual(x, y) - self.assertTrue(x is not y) - self.assertTrue(x["foo"] is y["foo"]) - y = copy.deepcopy(x) - self.assertEqual(x, y) - self.assertTrue(x is not y) - self.assertTrue(x["foo"] is not y["foo"]) - - def test_copy_slots(self): - class C(object): - __slots__ = ["foo"] - x = C() - x.foo = [42] - y = copy.copy(x) - self.assertTrue(x.foo is y.foo) - - def test_deepcopy_slots(self): - class C(object): - __slots__ = ["foo"] - x = C() - x.foo = [42] - y = copy.deepcopy(x) - self.assertEqual(x.foo, y.foo) - self.assertTrue(x.foo is not y.foo) - - def test_deepcopy_dict_subclass(self): - class C(dict): - def __init__(self, d=None): - if not d: - d = {} - self._keys = list(d.keys()) - dict.__init__(self, d) - def __setitem__(self, key, item): - dict.__setitem__(self, key, item) - if key not in self._keys: - self._keys.append(key) - x = C(d={'foo':0}) - y = copy.deepcopy(x) - self.assertEqual(x, y) - self.assertEqual(x._keys, y._keys) - self.assertTrue(x is not y) - x['bar'] = 1 - self.assertNotEqual(x, y) - self.assertNotEqual(x._keys, y._keys) - - def test_copy_list_subclass(self): - class C(list): - pass - x = C([[1, 2], 3]) - x.foo = [4, 5] - y = copy.copy(x) - self.assertEqual(list(x), list(y)) - self.assertEqual(x.foo, y.foo) - self.assertTrue(x[0] is y[0]) - self.assertTrue(x.foo is y.foo) - - def test_deepcopy_list_subclass(self): - class C(list): - pass - x = C([[1, 2], 3]) - x.foo = [4, 5] - y = copy.deepcopy(x) - self.assertEqual(list(x), list(y)) - self.assertEqual(x.foo, y.foo) - self.assertTrue(x[0] is not y[0]) - self.assertTrue(x.foo is not y.foo) - - def test_copy_tuple_subclass(self): - class C(tuple): - pass - x = C([1, 2, 3]) - self.assertEqual(tuple(x), (1, 2, 3)) - y = copy.copy(x) - self.assertEqual(tuple(y), (1, 2, 3)) - - def test_deepcopy_tuple_subclass(self): - class C(tuple): - pass - x = C([[1, 2], 3]) - self.assertEqual(tuple(x), ([1, 2], 3)) - y = copy.deepcopy(x) - self.assertEqual(tuple(y), ([1, 2], 3)) - self.assertTrue(x is not y) - self.assertTrue(x[0] is not y[0]) - - def test_getstate_exc(self): - class EvilState(object): - def __getstate__(self): - raise ValueError, "ain't got no stickin' state" - self.assertRaises(ValueError, copy.copy, EvilState()) - - def test_copy_function(self): - self.assertEqual(copy.copy(global_foo), global_foo) - def foo(x, y): return x+y - self.assertEqual(copy.copy(foo), foo) - bar = lambda: None - self.assertEqual(copy.copy(bar), bar) - - def test_deepcopy_function(self): - self.assertEqual(copy.deepcopy(global_foo), global_foo) - def foo(x, y): return x+y - self.assertEqual(copy.deepcopy(foo), foo) - bar = lambda: None - self.assertEqual(copy.deepcopy(bar), bar) - - def _check_weakref(self, _copy): - class C(object): - pass - obj = C() - x = weakref.ref(obj) - y = _copy(x) - self.assertTrue(y is x) - del obj - y = _copy(x) - self.assertTrue(y is x) - - def test_copy_weakref(self): - self._check_weakref(copy.copy) - - def test_deepcopy_weakref(self): - self._check_weakref(copy.deepcopy) - - def _check_copy_weakdict(self, _dicttype): - class C(object): - pass - a, b, c, d = [C() for i in xrange(4)] - u = _dicttype() - u[a] = b - u[c] = d - v = copy.copy(u) - self.assertFalse(v is u) - self.assertEqual(v, u) - self.assertEqual(v[a], b) - self.assertEqual(v[c], d) - self.assertEqual(len(v), 2) - del c, d - self.assertEqual(len(v), 1) - x, y = C(), C() - # The underlying containers are decoupled - v[x] = y - self.assertNotIn(x, u) - - def test_copy_weakkeydict(self): - self._check_copy_weakdict(weakref.WeakKeyDictionary) - - def test_copy_weakvaluedict(self): - self._check_copy_weakdict(weakref.WeakValueDictionary) - - def test_deepcopy_weakkeydict(self): - class C(object): - def __init__(self, i): - self.i = i - a, b, c, d = [C(i) for i in xrange(4)] - u = weakref.WeakKeyDictionary() - u[a] = b - u[c] = d - # Keys aren't copied, values are - v = copy.deepcopy(u) - self.assertNotEqual(v, u) - self.assertEqual(len(v), 2) - self.assertFalse(v[a] is b) - self.assertFalse(v[c] is d) - self.assertEqual(v[a].i, b.i) - self.assertEqual(v[c].i, d.i) - del c - self.assertEqual(len(v), 1) - - def test_deepcopy_weakvaluedict(self): - class C(object): - def __init__(self, i): - self.i = i - a, b, c, d = [C(i) for i in xrange(4)] - u = weakref.WeakValueDictionary() - u[a] = b - u[c] = d - # Keys are copied, values aren't - v = copy.deepcopy(u) - self.assertNotEqual(v, u) - self.assertEqual(len(v), 2) - (x, y), (z, t) = sorted(v.items(), key=lambda pair: pair[0].i) - self.assertFalse(x is a) - self.assertEqual(x.i, a.i) - self.assertTrue(y is b) - self.assertFalse(z is c) - self.assertEqual(z.i, c.i) - self.assertTrue(t is d) - del x, y, z, t - del d - self.assertEqual(len(v), 1) - - def test_deepcopy_bound_method(self): - class Foo(object): - def m(self): - pass - f = Foo() - f.b = f.m - g = copy.deepcopy(f) - self.assertEqual(g.m, g.b) - self.assertTrue(g.b.im_self is g) - g.b() - - -def global_foo(x, y): return x+y - -def test_main(): - test_support.run_unittest(TestCopy) - -if __name__ == "__main__": - test_main() |