Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 1 | """Unit tests for the copy module.""" |
| 2 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 3 | import copy |
Alexandre Vassalotti | f7fa63d | 2008-05-11 08:55:36 +0000 | [diff] [blame] | 4 | import copyreg |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 5 | import weakref |
Alexandre Vassalotti | 5c1c3b4 | 2013-12-01 13:25:26 -0800 | [diff] [blame] | 6 | import abc |
Mark Dickinson | a56c467 | 2009-01-27 18:17:45 +0000 | [diff] [blame] | 7 | from operator import le, lt, ge, gt, eq, ne |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 8 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 9 | import unittest |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 10 | |
Mark Dickinson | a56c467 | 2009-01-27 18:17:45 +0000 | [diff] [blame] | 11 | order_comparisons = le, lt, ge, gt |
| 12 | equality_comparisons = eq, ne |
| 13 | comparisons = order_comparisons + equality_comparisons |
| 14 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 15 | class TestCopy(unittest.TestCase): |
| 16 | |
| 17 | # Attempt full line coverage of copy.py from top to bottom |
| 18 | |
| 19 | def test_exceptions(self): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 20 | self.assertIs(copy.Error, copy.error) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 21 | self.assertTrue(issubclass(copy.Error, Exception)) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 22 | |
| 23 | # The copy() method |
| 24 | |
| 25 | def test_copy_basic(self): |
| 26 | x = 42 |
| 27 | y = copy.copy(x) |
| 28 | self.assertEqual(x, y) |
| 29 | |
| 30 | def test_copy_copy(self): |
| 31 | class C(object): |
| 32 | def __init__(self, foo): |
| 33 | self.foo = foo |
| 34 | def __copy__(self): |
| 35 | return C(self.foo) |
| 36 | x = C(42) |
| 37 | y = copy.copy(x) |
| 38 | self.assertEqual(y.__class__, x.__class__) |
| 39 | self.assertEqual(y.foo, x.foo) |
| 40 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 41 | def test_copy_registry(self): |
| 42 | class C(object): |
| 43 | def __new__(cls, foo): |
| 44 | obj = object.__new__(cls) |
| 45 | obj.foo = foo |
| 46 | return obj |
| 47 | def pickle_C(obj): |
| 48 | return (C, (obj.foo,)) |
| 49 | x = C(42) |
| 50 | self.assertRaises(TypeError, copy.copy, x) |
Alexandre Vassalotti | f7fa63d | 2008-05-11 08:55:36 +0000 | [diff] [blame] | 51 | copyreg.pickle(C, pickle_C, C) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 52 | y = copy.copy(x) |
| 53 | |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 54 | def test_copy_reduce_ex(self): |
| 55 | class C(object): |
| 56 | def __reduce_ex__(self, proto): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 57 | c.append(1) |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 58 | return "" |
| 59 | def __reduce__(self): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 60 | self.fail("shouldn't call this") |
| 61 | c = [] |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 62 | x = C() |
| 63 | y = copy.copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 64 | self.assertIs(y, x) |
| 65 | self.assertEqual(c, [1]) |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 66 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 67 | def test_copy_reduce(self): |
| 68 | class C(object): |
| 69 | def __reduce__(self): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 70 | c.append(1) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 71 | return "" |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 72 | c = [] |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 73 | x = C() |
| 74 | y = copy.copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 75 | self.assertIs(y, x) |
| 76 | self.assertEqual(c, [1]) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 77 | |
| 78 | def test_copy_cant(self): |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 79 | class C(object): |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 80 | def __getattribute__(self, name): |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 81 | if name.startswith("__reduce"): |
Collin Winter | 3add4d7 | 2007-08-29 23:37:32 +0000 | [diff] [blame] | 82 | raise AttributeError(name) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 83 | return object.__getattribute__(self, name) |
| 84 | x = C() |
| 85 | self.assertRaises(copy.Error, copy.copy, x) |
| 86 | |
| 87 | # Type-specific _copy_xxx() methods |
| 88 | |
| 89 | def test_copy_atomic(self): |
| 90 | class Classic: |
| 91 | pass |
| 92 | class NewStyle(object): |
| 93 | pass |
| 94 | def f(): |
| 95 | pass |
Alexandre Vassalotti | 5c1c3b4 | 2013-12-01 13:25:26 -0800 | [diff] [blame] | 96 | class WithMetaclass(metaclass=abc.ABCMeta): |
| 97 | pass |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 98 | tests = [None, ..., NotImplemented, |
| 99 | 42, 2**100, 3.14, True, False, 1j, |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 100 | "hello", "hello\u1234", f.__code__, |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 101 | b"world", bytes(range(256)), range(10), slice(1, 10, 2), |
| 102 | NewStyle, Classic, max, WithMetaclass] |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 103 | for x in tests: |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 104 | self.assertIs(copy.copy(x), x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 105 | |
| 106 | def test_copy_list(self): |
| 107 | x = [1, 2, 3] |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 108 | y = copy.copy(x) |
| 109 | self.assertEqual(y, x) |
| 110 | self.assertIsNot(y, x) |
| 111 | x = [] |
| 112 | y = copy.copy(x) |
| 113 | self.assertEqual(y, x) |
| 114 | self.assertIsNot(y, x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 115 | |
| 116 | def test_copy_tuple(self): |
| 117 | x = (1, 2, 3) |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 118 | self.assertIs(copy.copy(x), x) |
| 119 | x = () |
| 120 | self.assertIs(copy.copy(x), x) |
| 121 | x = (1, 2, 3, []) |
| 122 | self.assertIs(copy.copy(x), x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 123 | |
| 124 | def test_copy_dict(self): |
| 125 | x = {"foo": 1, "bar": 2} |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 126 | y = copy.copy(x) |
| 127 | self.assertEqual(y, x) |
| 128 | self.assertIsNot(y, x) |
| 129 | x = {} |
| 130 | y = copy.copy(x) |
| 131 | self.assertEqual(y, x) |
| 132 | self.assertIsNot(y, x) |
| 133 | |
| 134 | def test_copy_set(self): |
| 135 | x = {1, 2, 3} |
| 136 | y = copy.copy(x) |
| 137 | self.assertEqual(y, x) |
| 138 | self.assertIsNot(y, x) |
| 139 | x = set() |
| 140 | y = copy.copy(x) |
| 141 | self.assertEqual(y, x) |
| 142 | self.assertIsNot(y, x) |
| 143 | |
| 144 | def test_copy_frozenset(self): |
| 145 | x = frozenset({1, 2, 3}) |
| 146 | self.assertIs(copy.copy(x), x) |
| 147 | x = frozenset() |
| 148 | self.assertIs(copy.copy(x), x) |
| 149 | |
| 150 | def test_copy_bytearray(self): |
| 151 | x = bytearray(b'abc') |
| 152 | y = copy.copy(x) |
| 153 | self.assertEqual(y, x) |
| 154 | self.assertIsNot(y, x) |
| 155 | x = bytearray() |
| 156 | y = copy.copy(x) |
| 157 | self.assertEqual(y, x) |
| 158 | self.assertIsNot(y, x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 159 | |
| 160 | def test_copy_inst_vanilla(self): |
| 161 | class C: |
| 162 | def __init__(self, foo): |
| 163 | self.foo = foo |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 164 | def __eq__(self, other): |
| 165 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 166 | x = C(42) |
| 167 | self.assertEqual(copy.copy(x), x) |
| 168 | |
| 169 | def test_copy_inst_copy(self): |
| 170 | class C: |
| 171 | def __init__(self, foo): |
| 172 | self.foo = foo |
| 173 | def __copy__(self): |
| 174 | return C(self.foo) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 175 | def __eq__(self, other): |
| 176 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 177 | x = C(42) |
| 178 | self.assertEqual(copy.copy(x), x) |
| 179 | |
| 180 | def test_copy_inst_getinitargs(self): |
| 181 | class C: |
| 182 | def __init__(self, foo): |
| 183 | self.foo = foo |
| 184 | def __getinitargs__(self): |
| 185 | return (self.foo,) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 186 | def __eq__(self, other): |
| 187 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 188 | x = C(42) |
| 189 | self.assertEqual(copy.copy(x), x) |
| 190 | |
Serhiy Storchaka | 32af754 | 2015-03-24 18:06:42 +0200 | [diff] [blame] | 191 | def test_copy_inst_getnewargs(self): |
| 192 | class C(int): |
| 193 | def __new__(cls, foo): |
| 194 | self = int.__new__(cls) |
| 195 | self.foo = foo |
| 196 | return self |
| 197 | def __getnewargs__(self): |
| 198 | return self.foo, |
| 199 | def __eq__(self, other): |
| 200 | return self.foo == other.foo |
| 201 | x = C(42) |
| 202 | y = copy.copy(x) |
| 203 | self.assertIsInstance(y, C) |
| 204 | self.assertEqual(y, x) |
| 205 | self.assertIsNot(y, x) |
| 206 | self.assertEqual(y.foo, x.foo) |
| 207 | |
| 208 | def test_copy_inst_getnewargs_ex(self): |
| 209 | class C(int): |
| 210 | def __new__(cls, *, foo): |
| 211 | self = int.__new__(cls) |
| 212 | self.foo = foo |
| 213 | return self |
| 214 | def __getnewargs_ex__(self): |
| 215 | return (), {'foo': self.foo} |
| 216 | def __eq__(self, other): |
| 217 | return self.foo == other.foo |
| 218 | x = C(foo=42) |
| 219 | y = copy.copy(x) |
| 220 | self.assertIsInstance(y, C) |
| 221 | self.assertEqual(y, x) |
| 222 | self.assertIsNot(y, x) |
| 223 | self.assertEqual(y.foo, x.foo) |
| 224 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 225 | def test_copy_inst_getstate(self): |
| 226 | class C: |
| 227 | def __init__(self, foo): |
| 228 | self.foo = foo |
| 229 | def __getstate__(self): |
| 230 | return {"foo": self.foo} |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 231 | def __eq__(self, other): |
| 232 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 233 | x = C(42) |
| 234 | self.assertEqual(copy.copy(x), x) |
| 235 | |
| 236 | def test_copy_inst_setstate(self): |
| 237 | class C: |
| 238 | def __init__(self, foo): |
| 239 | self.foo = foo |
| 240 | def __setstate__(self, state): |
| 241 | self.foo = state["foo"] |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 242 | def __eq__(self, other): |
| 243 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 244 | x = C(42) |
| 245 | self.assertEqual(copy.copy(x), x) |
| 246 | |
| 247 | def test_copy_inst_getstate_setstate(self): |
| 248 | class C: |
| 249 | def __init__(self, foo): |
| 250 | self.foo = foo |
| 251 | def __getstate__(self): |
| 252 | return self.foo |
| 253 | def __setstate__(self, state): |
| 254 | self.foo = state |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 255 | def __eq__(self, other): |
| 256 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 257 | x = C(42) |
| 258 | self.assertEqual(copy.copy(x), x) |
Serhiy Storchaka | cbbec1c | 2015-11-30 17:20:02 +0200 | [diff] [blame] | 259 | # State with boolean value is false (issue #25718) |
| 260 | x = C(0.0) |
| 261 | self.assertEqual(copy.copy(x), x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 262 | |
| 263 | # The deepcopy() method |
| 264 | |
| 265 | def test_deepcopy_basic(self): |
| 266 | x = 42 |
| 267 | y = copy.deepcopy(x) |
| 268 | self.assertEqual(y, x) |
| 269 | |
| 270 | def test_deepcopy_memo(self): |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 271 | # Tests of reflexive objects are under type-specific sections below. |
| 272 | # This tests only repetitions of objects. |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 273 | x = [] |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 274 | x = [x, x] |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 275 | y = copy.deepcopy(x) |
| 276 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 277 | self.assertIsNot(y, x) |
| 278 | self.assertIsNot(y[0], x[0]) |
| 279 | self.assertIs(y[0], y[1]) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 280 | |
| 281 | def test_deepcopy_issubclass(self): |
| 282 | # XXX Note: there's no way to test the TypeError coming out of |
| 283 | # issubclass() -- this can only happen when an extension |
| 284 | # module defines a "type" that doesn't formally inherit from |
| 285 | # type. |
| 286 | class Meta(type): |
| 287 | pass |
Guido van Rossum | 52cc1d8 | 2007-03-18 15:41:51 +0000 | [diff] [blame] | 288 | class C(metaclass=Meta): |
| 289 | pass |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 290 | self.assertEqual(copy.deepcopy(C), C) |
| 291 | |
| 292 | def test_deepcopy_deepcopy(self): |
| 293 | class C(object): |
| 294 | def __init__(self, foo): |
| 295 | self.foo = foo |
| 296 | def __deepcopy__(self, memo=None): |
| 297 | return C(self.foo) |
| 298 | x = C(42) |
| 299 | y = copy.deepcopy(x) |
| 300 | self.assertEqual(y.__class__, x.__class__) |
| 301 | self.assertEqual(y.foo, x.foo) |
| 302 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 303 | def test_deepcopy_registry(self): |
| 304 | class C(object): |
| 305 | def __new__(cls, foo): |
| 306 | obj = object.__new__(cls) |
| 307 | obj.foo = foo |
| 308 | return obj |
| 309 | def pickle_C(obj): |
| 310 | return (C, (obj.foo,)) |
| 311 | x = C(42) |
| 312 | self.assertRaises(TypeError, copy.deepcopy, x) |
Alexandre Vassalotti | f7fa63d | 2008-05-11 08:55:36 +0000 | [diff] [blame] | 313 | copyreg.pickle(C, pickle_C, C) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 314 | y = copy.deepcopy(x) |
| 315 | |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 316 | def test_deepcopy_reduce_ex(self): |
| 317 | class C(object): |
| 318 | def __reduce_ex__(self, proto): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 319 | c.append(1) |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 320 | return "" |
| 321 | def __reduce__(self): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 322 | self.fail("shouldn't call this") |
| 323 | c = [] |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 324 | x = C() |
| 325 | y = copy.deepcopy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 326 | self.assertIs(y, x) |
| 327 | self.assertEqual(c, [1]) |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 328 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 329 | def test_deepcopy_reduce(self): |
| 330 | class C(object): |
| 331 | def __reduce__(self): |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 332 | c.append(1) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 333 | return "" |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 334 | c = [] |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 335 | x = C() |
| 336 | y = copy.deepcopy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 337 | self.assertIs(y, x) |
| 338 | self.assertEqual(c, [1]) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 339 | |
| 340 | def test_deepcopy_cant(self): |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 341 | class C(object): |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 342 | def __getattribute__(self, name): |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 343 | if name.startswith("__reduce"): |
Collin Winter | 3add4d7 | 2007-08-29 23:37:32 +0000 | [diff] [blame] | 344 | raise AttributeError(name) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 345 | return object.__getattribute__(self, name) |
| 346 | x = C() |
| 347 | self.assertRaises(copy.Error, copy.deepcopy, x) |
| 348 | |
| 349 | # Type-specific _deepcopy_xxx() methods |
| 350 | |
| 351 | def test_deepcopy_atomic(self): |
| 352 | class Classic: |
| 353 | pass |
| 354 | class NewStyle(object): |
| 355 | pass |
| 356 | def f(): |
| 357 | pass |
Guido van Rossum | e2a383d | 2007-01-15 16:59:06 +0000 | [diff] [blame] | 358 | tests = [None, 42, 2**100, 3.14, True, False, 1j, |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 359 | "hello", "hello\u1234", f.__code__, |
Serhiy Storchaka | 0a20bbf | 2016-01-28 21:43:35 +0200 | [diff] [blame] | 360 | NewStyle, Classic, max] |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 361 | for x in tests: |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 362 | self.assertIs(copy.deepcopy(x), x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 363 | |
| 364 | def test_deepcopy_list(self): |
| 365 | x = [[1, 2], 3] |
| 366 | y = copy.deepcopy(x) |
| 367 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 368 | self.assertIsNot(x, y) |
| 369 | self.assertIsNot(x[0], y[0]) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 370 | |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 371 | def test_deepcopy_reflexive_list(self): |
| 372 | x = [] |
| 373 | x.append(x) |
| 374 | y = copy.deepcopy(x) |
Mark Dickinson | a56c467 | 2009-01-27 18:17:45 +0000 | [diff] [blame] | 375 | for op in comparisons: |
Yury Selivanov | f488fb4 | 2015-07-03 01:04:23 -0400 | [diff] [blame] | 376 | self.assertRaises(RecursionError, op, y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 377 | self.assertIsNot(y, x) |
| 378 | self.assertIs(y[0], y) |
Armin Rigo | 2b3eb40 | 2003-10-28 12:05:48 +0000 | [diff] [blame] | 379 | self.assertEqual(len(y), 1) |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 380 | |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 381 | def test_deepcopy_empty_tuple(self): |
| 382 | x = () |
| 383 | y = copy.deepcopy(x) |
| 384 | self.assertIs(x, y) |
| 385 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 386 | def test_deepcopy_tuple(self): |
| 387 | x = ([1, 2], 3) |
| 388 | y = copy.deepcopy(x) |
| 389 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 390 | self.assertIsNot(x, y) |
| 391 | self.assertIsNot(x[0], y[0]) |
| 392 | |
| 393 | def test_deepcopy_tuple_of_immutables(self): |
| 394 | x = ((1, 2), 3) |
| 395 | y = copy.deepcopy(x) |
| 396 | self.assertIs(x, y) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 397 | |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 398 | def test_deepcopy_reflexive_tuple(self): |
| 399 | x = ([],) |
| 400 | x[0].append(x) |
| 401 | y = copy.deepcopy(x) |
Mark Dickinson | a56c467 | 2009-01-27 18:17:45 +0000 | [diff] [blame] | 402 | for op in comparisons: |
Yury Selivanov | f488fb4 | 2015-07-03 01:04:23 -0400 | [diff] [blame] | 403 | self.assertRaises(RecursionError, op, y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 404 | self.assertIsNot(y, x) |
| 405 | self.assertIsNot(y[0], x[0]) |
| 406 | self.assertIs(y[0][0], y) |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 407 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 408 | def test_deepcopy_dict(self): |
| 409 | x = {"foo": [1, 2], "bar": 3} |
| 410 | y = copy.deepcopy(x) |
| 411 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 412 | self.assertIsNot(x, y) |
| 413 | self.assertIsNot(x["foo"], y["foo"]) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 414 | |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 415 | def test_deepcopy_reflexive_dict(self): |
| 416 | x = {} |
| 417 | x['foo'] = x |
| 418 | y = copy.deepcopy(x) |
Mark Dickinson | a56c467 | 2009-01-27 18:17:45 +0000 | [diff] [blame] | 419 | for op in order_comparisons: |
| 420 | self.assertRaises(TypeError, op, y, x) |
| 421 | for op in equality_comparisons: |
Yury Selivanov | f488fb4 | 2015-07-03 01:04:23 -0400 | [diff] [blame] | 422 | self.assertRaises(RecursionError, op, y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 423 | self.assertIsNot(y, x) |
| 424 | self.assertIs(y['foo'], y) |
Armin Rigo | 2b3eb40 | 2003-10-28 12:05:48 +0000 | [diff] [blame] | 425 | self.assertEqual(len(y), 1) |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 426 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 427 | def test_deepcopy_keepalive(self): |
| 428 | memo = {} |
Benjamin Peterson | e90ec36 | 2011-06-27 16:22:46 -0500 | [diff] [blame] | 429 | x = [] |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 430 | y = copy.deepcopy(x, memo) |
Benjamin Peterson | e90ec36 | 2011-06-27 16:22:46 -0500 | [diff] [blame] | 431 | self.assertIs(memo[id(memo)][0], x) |
| 432 | |
| 433 | def test_deepcopy_dont_memo_immutable(self): |
| 434 | memo = {} |
| 435 | x = [1, 2, 3, 4] |
| 436 | y = copy.deepcopy(x, memo) |
| 437 | self.assertEqual(y, x) |
| 438 | # There's the entry for the new list, and the keep alive. |
| 439 | self.assertEqual(len(memo), 2) |
| 440 | |
| 441 | memo = {} |
| 442 | x = [(1, 2)] |
| 443 | y = copy.deepcopy(x, memo) |
| 444 | self.assertEqual(y, x) |
| 445 | # Tuples with immutable contents are immutable for deepcopy. |
| 446 | self.assertEqual(len(memo), 2) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 447 | |
| 448 | def test_deepcopy_inst_vanilla(self): |
| 449 | class C: |
| 450 | def __init__(self, foo): |
| 451 | self.foo = foo |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 452 | def __eq__(self, other): |
| 453 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 454 | x = C([42]) |
| 455 | y = copy.deepcopy(x) |
| 456 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 457 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 458 | |
| 459 | def test_deepcopy_inst_deepcopy(self): |
| 460 | class C: |
| 461 | def __init__(self, foo): |
| 462 | self.foo = foo |
| 463 | def __deepcopy__(self, memo): |
| 464 | return C(copy.deepcopy(self.foo, memo)) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 465 | def __eq__(self, other): |
| 466 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 467 | x = C([42]) |
| 468 | y = copy.deepcopy(x) |
| 469 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 470 | self.assertIsNot(y, x) |
| 471 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 472 | |
| 473 | def test_deepcopy_inst_getinitargs(self): |
| 474 | class C: |
| 475 | def __init__(self, foo): |
| 476 | self.foo = foo |
| 477 | def __getinitargs__(self): |
| 478 | return (self.foo,) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 479 | def __eq__(self, other): |
| 480 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 481 | x = C([42]) |
| 482 | y = copy.deepcopy(x) |
| 483 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 484 | self.assertIsNot(y, x) |
| 485 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 486 | |
Serhiy Storchaka | 32af754 | 2015-03-24 18:06:42 +0200 | [diff] [blame] | 487 | def test_deepcopy_inst_getnewargs(self): |
| 488 | class C(int): |
| 489 | def __new__(cls, foo): |
| 490 | self = int.__new__(cls) |
| 491 | self.foo = foo |
| 492 | return self |
| 493 | def __getnewargs__(self): |
| 494 | return self.foo, |
| 495 | def __eq__(self, other): |
| 496 | return self.foo == other.foo |
| 497 | x = C([42]) |
| 498 | y = copy.deepcopy(x) |
| 499 | self.assertIsInstance(y, C) |
| 500 | self.assertEqual(y, x) |
| 501 | self.assertIsNot(y, x) |
| 502 | self.assertEqual(y.foo, x.foo) |
| 503 | self.assertIsNot(y.foo, x.foo) |
| 504 | |
| 505 | def test_deepcopy_inst_getnewargs_ex(self): |
| 506 | class C(int): |
| 507 | def __new__(cls, *, foo): |
| 508 | self = int.__new__(cls) |
| 509 | self.foo = foo |
| 510 | return self |
| 511 | def __getnewargs_ex__(self): |
| 512 | return (), {'foo': self.foo} |
| 513 | def __eq__(self, other): |
| 514 | return self.foo == other.foo |
| 515 | x = C(foo=[42]) |
| 516 | y = copy.deepcopy(x) |
| 517 | self.assertIsInstance(y, C) |
| 518 | self.assertEqual(y, x) |
| 519 | self.assertIsNot(y, x) |
| 520 | self.assertEqual(y.foo, x.foo) |
| 521 | self.assertIsNot(y.foo, x.foo) |
| 522 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 523 | def test_deepcopy_inst_getstate(self): |
| 524 | class C: |
| 525 | def __init__(self, foo): |
| 526 | self.foo = foo |
| 527 | def __getstate__(self): |
| 528 | return {"foo": self.foo} |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 529 | def __eq__(self, other): |
| 530 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 531 | x = C([42]) |
| 532 | y = copy.deepcopy(x) |
| 533 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 534 | self.assertIsNot(y, x) |
| 535 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 536 | |
| 537 | def test_deepcopy_inst_setstate(self): |
| 538 | class C: |
| 539 | def __init__(self, foo): |
| 540 | self.foo = foo |
| 541 | def __setstate__(self, state): |
| 542 | self.foo = state["foo"] |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 543 | def __eq__(self, other): |
| 544 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 545 | x = C([42]) |
| 546 | y = copy.deepcopy(x) |
| 547 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 548 | self.assertIsNot(y, x) |
| 549 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 550 | |
| 551 | def test_deepcopy_inst_getstate_setstate(self): |
| 552 | class C: |
| 553 | def __init__(self, foo): |
| 554 | self.foo = foo |
| 555 | def __getstate__(self): |
| 556 | return self.foo |
| 557 | def __setstate__(self, state): |
| 558 | self.foo = state |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 559 | def __eq__(self, other): |
| 560 | return self.foo == other.foo |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 561 | x = C([42]) |
| 562 | y = copy.deepcopy(x) |
| 563 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 564 | self.assertIsNot(y, x) |
| 565 | self.assertIsNot(y.foo, x.foo) |
Serhiy Storchaka | cbbec1c | 2015-11-30 17:20:02 +0200 | [diff] [blame] | 566 | # State with boolean value is false (issue #25718) |
| 567 | x = C([]) |
| 568 | y = copy.deepcopy(x) |
| 569 | self.assertEqual(y, x) |
| 570 | self.assertIsNot(y, x) |
| 571 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 572 | |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 573 | def test_deepcopy_reflexive_inst(self): |
| 574 | class C: |
| 575 | pass |
| 576 | x = C() |
| 577 | x.foo = x |
| 578 | y = copy.deepcopy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 579 | self.assertIsNot(y, x) |
| 580 | self.assertIs(y.foo, y) |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 581 | |
Serhiy Storchaka | 0a20bbf | 2016-01-28 21:43:35 +0200 | [diff] [blame] | 582 | def test_deepcopy_range(self): |
| 583 | class I(int): |
| 584 | pass |
| 585 | x = range(I(10)) |
| 586 | y = copy.deepcopy(x) |
| 587 | self.assertIsNot(y, x) |
| 588 | self.assertEqual(y, x) |
| 589 | self.assertIsNot(y.stop, x.stop) |
| 590 | self.assertEqual(y.stop, x.stop) |
| 591 | self.assertIsInstance(y.stop, I) |
| 592 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 593 | # _reconstruct() |
| 594 | |
| 595 | def test_reconstruct_string(self): |
| 596 | class C(object): |
| 597 | def __reduce__(self): |
| 598 | return "" |
| 599 | x = C() |
| 600 | y = copy.copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 601 | self.assertIs(y, x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 602 | y = copy.deepcopy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 603 | self.assertIs(y, x) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 604 | |
| 605 | def test_reconstruct_nostate(self): |
| 606 | class C(object): |
| 607 | def __reduce__(self): |
| 608 | return (C, ()) |
| 609 | x = C() |
| 610 | x.foo = 42 |
| 611 | y = copy.copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 612 | self.assertIs(y.__class__, x.__class__) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 613 | y = copy.deepcopy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 614 | self.assertIs(y.__class__, x.__class__) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 615 | |
| 616 | def test_reconstruct_state(self): |
| 617 | class C(object): |
| 618 | def __reduce__(self): |
| 619 | return (C, (), self.__dict__) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 620 | def __eq__(self, other): |
| 621 | return self.__dict__ == other.__dict__ |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 622 | x = C() |
| 623 | x.foo = [42] |
| 624 | y = copy.copy(x) |
| 625 | self.assertEqual(y, x) |
| 626 | y = copy.deepcopy(x) |
| 627 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 628 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 629 | |
| 630 | def test_reconstruct_state_setstate(self): |
| 631 | class C(object): |
| 632 | def __reduce__(self): |
| 633 | return (C, (), self.__dict__) |
| 634 | def __setstate__(self, state): |
| 635 | self.__dict__.update(state) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 636 | def __eq__(self, other): |
| 637 | return self.__dict__ == other.__dict__ |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 638 | x = C() |
| 639 | x.foo = [42] |
| 640 | y = copy.copy(x) |
| 641 | self.assertEqual(y, x) |
| 642 | y = copy.deepcopy(x) |
| 643 | self.assertEqual(y, x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 644 | self.assertIsNot(y.foo, x.foo) |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 645 | |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 646 | def test_reconstruct_reflexive(self): |
| 647 | class C(object): |
| 648 | pass |
| 649 | x = C() |
| 650 | x.foo = x |
| 651 | y = copy.deepcopy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 652 | self.assertIsNot(y, x) |
| 653 | self.assertIs(y.foo, y) |
Guido van Rossum | 99d2c25 | 2003-06-13 19:28:47 +0000 | [diff] [blame] | 654 | |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 655 | # Additions for Python 2.3 and pickle protocol 2 |
| 656 | |
| 657 | def test_reduce_4tuple(self): |
| 658 | class C(list): |
| 659 | def __reduce__(self): |
| 660 | return (C, (), self.__dict__, iter(self)) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 661 | def __eq__(self, other): |
| 662 | return (list(self) == list(other) and |
| 663 | self.__dict__ == other.__dict__) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 664 | x = C([[1, 2], 3]) |
| 665 | y = copy.copy(x) |
| 666 | self.assertEqual(x, y) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 667 | self.assertIsNot(x, y) |
| 668 | self.assertIs(x[0], y[0]) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 669 | y = copy.deepcopy(x) |
| 670 | self.assertEqual(x, y) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 671 | self.assertIsNot(x, y) |
| 672 | self.assertIsNot(x[0], y[0]) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 673 | |
| 674 | def test_reduce_5tuple(self): |
| 675 | class C(dict): |
| 676 | def __reduce__(self): |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 677 | return (C, (), self.__dict__, None, self.items()) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 678 | def __eq__(self, other): |
| 679 | return (dict(self) == dict(other) and |
| 680 | self.__dict__ == other.__dict__) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 681 | x = C([("foo", [1, 2]), ("bar", 3)]) |
| 682 | y = copy.copy(x) |
| 683 | self.assertEqual(x, y) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 684 | self.assertIsNot(x, y) |
| 685 | self.assertIs(x["foo"], y["foo"]) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 686 | y = copy.deepcopy(x) |
| 687 | self.assertEqual(x, y) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 688 | self.assertIsNot(x, y) |
| 689 | self.assertIsNot(x["foo"], y["foo"]) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 690 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 691 | def test_copy_slots(self): |
| 692 | class C(object): |
| 693 | __slots__ = ["foo"] |
| 694 | x = C() |
| 695 | x.foo = [42] |
| 696 | y = copy.copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 697 | self.assertIs(x.foo, y.foo) |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 698 | |
| 699 | def test_deepcopy_slots(self): |
| 700 | class C(object): |
| 701 | __slots__ = ["foo"] |
| 702 | x = C() |
| 703 | x.foo = [42] |
| 704 | y = copy.deepcopy(x) |
| 705 | self.assertEqual(x.foo, y.foo) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 706 | self.assertIsNot(x.foo, y.foo) |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 707 | |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 708 | def test_deepcopy_dict_subclass(self): |
| 709 | class C(dict): |
| 710 | def __init__(self, d=None): |
| 711 | if not d: |
| 712 | d = {} |
| 713 | self._keys = list(d.keys()) |
| 714 | super().__init__(d) |
| 715 | def __setitem__(self, key, item): |
| 716 | super().__setitem__(key, item) |
| 717 | if key not in self._keys: |
| 718 | self._keys.append(key) |
| 719 | x = C(d={'foo':0}) |
| 720 | y = copy.deepcopy(x) |
| 721 | self.assertEqual(x, y) |
| 722 | self.assertEqual(x._keys, y._keys) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 723 | self.assertIsNot(x, y) |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 724 | x['bar'] = 1 |
| 725 | self.assertNotEqual(x, y) |
| 726 | self.assertNotEqual(x._keys, y._keys) |
| 727 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 728 | def test_copy_list_subclass(self): |
| 729 | class C(list): |
| 730 | pass |
| 731 | x = C([[1, 2], 3]) |
| 732 | x.foo = [4, 5] |
| 733 | y = copy.copy(x) |
| 734 | self.assertEqual(list(x), list(y)) |
| 735 | self.assertEqual(x.foo, y.foo) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 736 | self.assertIs(x[0], y[0]) |
| 737 | self.assertIs(x.foo, y.foo) |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 738 | |
| 739 | def test_deepcopy_list_subclass(self): |
| 740 | class C(list): |
| 741 | pass |
| 742 | x = C([[1, 2], 3]) |
| 743 | x.foo = [4, 5] |
| 744 | y = copy.deepcopy(x) |
| 745 | self.assertEqual(list(x), list(y)) |
| 746 | self.assertEqual(x.foo, y.foo) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 747 | self.assertIsNot(x[0], y[0]) |
| 748 | self.assertIsNot(x.foo, y.foo) |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 749 | |
Guido van Rossum | 85233bf | 2003-02-06 21:25:12 +0000 | [diff] [blame] | 750 | def test_copy_tuple_subclass(self): |
| 751 | class C(tuple): |
| 752 | pass |
| 753 | x = C([1, 2, 3]) |
| 754 | self.assertEqual(tuple(x), (1, 2, 3)) |
| 755 | y = copy.copy(x) |
| 756 | self.assertEqual(tuple(y), (1, 2, 3)) |
| 757 | |
| 758 | def test_deepcopy_tuple_subclass(self): |
| 759 | class C(tuple): |
| 760 | pass |
| 761 | x = C([[1, 2], 3]) |
| 762 | self.assertEqual(tuple(x), ([1, 2], 3)) |
| 763 | y = copy.deepcopy(x) |
| 764 | self.assertEqual(tuple(y), ([1, 2], 3)) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 765 | self.assertIsNot(x, y) |
| 766 | self.assertIsNot(x[0], y[0]) |
Guido van Rossum | 85233bf | 2003-02-06 21:25:12 +0000 | [diff] [blame] | 767 | |
Neal Norwitz | e2fdc61 | 2003-06-08 13:19:58 +0000 | [diff] [blame] | 768 | def test_getstate_exc(self): |
| 769 | class EvilState(object): |
| 770 | def __getstate__(self): |
Collin Winter | 3add4d7 | 2007-08-29 23:37:32 +0000 | [diff] [blame] | 771 | raise ValueError("ain't got no stickin' state") |
Neal Norwitz | e2fdc61 | 2003-06-08 13:19:58 +0000 | [diff] [blame] | 772 | self.assertRaises(ValueError, copy.copy, EvilState()) |
| 773 | |
Guido van Rossum | 1968ad3 | 2006-02-25 22:38:04 +0000 | [diff] [blame] | 774 | def test_copy_function(self): |
| 775 | self.assertEqual(copy.copy(global_foo), global_foo) |
| 776 | def foo(x, y): return x+y |
| 777 | self.assertEqual(copy.copy(foo), foo) |
| 778 | bar = lambda: None |
| 779 | self.assertEqual(copy.copy(bar), bar) |
| 780 | |
| 781 | def test_deepcopy_function(self): |
| 782 | self.assertEqual(copy.deepcopy(global_foo), global_foo) |
| 783 | def foo(x, y): return x+y |
| 784 | self.assertEqual(copy.deepcopy(foo), foo) |
| 785 | bar = lambda: None |
| 786 | self.assertEqual(copy.deepcopy(bar), bar) |
| 787 | |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 788 | def _check_weakref(self, _copy): |
| 789 | class C(object): |
| 790 | pass |
| 791 | obj = C() |
| 792 | x = weakref.ref(obj) |
| 793 | y = _copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 794 | self.assertIs(y, x) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 795 | del obj |
| 796 | y = _copy(x) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 797 | self.assertIs(y, x) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 798 | |
| 799 | def test_copy_weakref(self): |
| 800 | self._check_weakref(copy.copy) |
| 801 | |
| 802 | def test_deepcopy_weakref(self): |
| 803 | self._check_weakref(copy.deepcopy) |
| 804 | |
| 805 | def _check_copy_weakdict(self, _dicttype): |
| 806 | class C(object): |
| 807 | pass |
| 808 | a, b, c, d = [C() for i in range(4)] |
| 809 | u = _dicttype() |
| 810 | u[a] = b |
| 811 | u[c] = d |
| 812 | v = copy.copy(u) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 813 | self.assertIsNot(v, u) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 814 | self.assertEqual(v, u) |
| 815 | self.assertEqual(v[a], b) |
| 816 | self.assertEqual(v[c], d) |
| 817 | self.assertEqual(len(v), 2) |
| 818 | del c, d |
| 819 | self.assertEqual(len(v), 1) |
| 820 | x, y = C(), C() |
| 821 | # The underlying containers are decoupled |
| 822 | v[x] = y |
Ezio Melotti | b58e0bd | 2010-01-23 15:40:09 +0000 | [diff] [blame] | 823 | self.assertNotIn(x, u) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 824 | |
| 825 | def test_copy_weakkeydict(self): |
| 826 | self._check_copy_weakdict(weakref.WeakKeyDictionary) |
| 827 | |
| 828 | def test_copy_weakvaluedict(self): |
| 829 | self._check_copy_weakdict(weakref.WeakValueDictionary) |
| 830 | |
| 831 | def test_deepcopy_weakkeydict(self): |
| 832 | class C(object): |
| 833 | def __init__(self, i): |
| 834 | self.i = i |
| 835 | a, b, c, d = [C(i) for i in range(4)] |
| 836 | u = weakref.WeakKeyDictionary() |
| 837 | u[a] = b |
| 838 | u[c] = d |
| 839 | # Keys aren't copied, values are |
| 840 | v = copy.deepcopy(u) |
| 841 | self.assertNotEqual(v, u) |
| 842 | self.assertEqual(len(v), 2) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 843 | self.assertIsNot(v[a], b) |
| 844 | self.assertIsNot(v[c], d) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 845 | self.assertEqual(v[a].i, b.i) |
| 846 | self.assertEqual(v[c].i, d.i) |
| 847 | del c |
| 848 | self.assertEqual(len(v), 1) |
| 849 | |
| 850 | def test_deepcopy_weakvaluedict(self): |
| 851 | class C(object): |
| 852 | def __init__(self, i): |
| 853 | self.i = i |
| 854 | a, b, c, d = [C(i) for i in range(4)] |
| 855 | u = weakref.WeakValueDictionary() |
| 856 | u[a] = b |
| 857 | u[c] = d |
| 858 | # Keys are copied, values aren't |
| 859 | v = copy.deepcopy(u) |
| 860 | self.assertNotEqual(v, u) |
| 861 | self.assertEqual(len(v), 2) |
| 862 | (x, y), (z, t) = sorted(v.items(), key=lambda pair: pair[0].i) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 863 | self.assertIsNot(x, a) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 864 | self.assertEqual(x.i, a.i) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 865 | self.assertIs(y, b) |
| 866 | self.assertIsNot(z, c) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 867 | self.assertEqual(z.i, c.i) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 868 | self.assertIs(t, d) |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 869 | del x, y, z, t |
| 870 | del d |
| 871 | self.assertEqual(len(v), 1) |
| 872 | |
Antoine Pitrou | 1fc0d2b | 2009-11-28 15:58:27 +0000 | [diff] [blame] | 873 | def test_deepcopy_bound_method(self): |
| 874 | class Foo(object): |
| 875 | def m(self): |
| 876 | pass |
| 877 | f = Foo() |
| 878 | f.b = f.m |
| 879 | g = copy.deepcopy(f) |
| 880 | self.assertEqual(g.m, g.b) |
Sandro Tosi | 4dc9c84 | 2011-08-05 23:05:35 +0200 | [diff] [blame] | 881 | self.assertIs(g.b.__self__, g) |
Antoine Pitrou | 1fc0d2b | 2009-11-28 15:58:27 +0000 | [diff] [blame] | 882 | g.b() |
| 883 | |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 884 | |
Guido van Rossum | 1968ad3 | 2006-02-25 22:38:04 +0000 | [diff] [blame] | 885 | def global_foo(x, y): return x+y |
| 886 | |
Guido van Rossum | 581cb93 | 2003-02-06 17:52:15 +0000 | [diff] [blame] | 887 | if __name__ == "__main__": |
Zachary Ware | 38c707e | 2015-04-13 15:00:43 -0500 | [diff] [blame] | 888 | unittest.main() |