Python code coverage for Lib/test/test_copy.py

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