text: """Unit tests for the copy module."""
  
  import cosmo
  import copy
  import copyreg
  import weakref
  import abc
  from operator import le, lt, ge, gt, eq, ne
  
  import unittest
  
  order_comparisons = le, lt, ge, gt
  equality_comparisons = eq, ne
  comparisons = order_comparisons + equality_comparisons
  
  class TestCopy(unittest.TestCase):
  
      # Attempt full line coverage of copy.py from top to bottom
  
      def test_exceptions(self):
          self.assertIs(copy.Error, 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)
          copyreg.pickle(C, pickle_C, C)
          y = copy.copy(x)
  
      def test_copy_reduce_ex(self):
          class C(object):
              def __reduce_ex__(self, proto):
                  c.append(1)
                  return ""
              def __reduce__(self):
                  self.fail("shouldn't call this")
          c = []
          x = C()
          y = copy.copy(x)
          self.assertIs(y, x)
          self.assertEqual(c, [1])
  
      def test_copy_reduce(self):
          class C(object):
              def __reduce__(self):
                  c.append(1)
                  return ""
          c = []
          x = C()
          y = copy.copy(x)
          self.assertIs(y, x)
          self.assertEqual(c, [1])
  
      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
          class WithMetaclass(metaclass=abc.ABCMeta):
              pass
          tests = [None, ..., NotImplemented,
                   42, 2**100, 3.14, True, False, 1j,
                   "hello", "hello\u1234", f.__code__,
                   b"world", bytes(range(256)), range(10), slice(1, 10, 2),
                   NewStyle, Classic, max, WithMetaclass]
          for x in tests:
              self.assertIs(copy.copy(x), x)
  
      def test_copy_list(self):
          x = [1, 2, 3]
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          x = []
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
  
      def test_copy_tuple(self):
          x = (1, 2, 3)
          self.assertIs(copy.copy(x), x)
          x = ()
          self.assertIs(copy.copy(x), x)
          x = (1, 2, 3, [])
          self.assertIs(copy.copy(x), x)
  
      def test_copy_dict(self):
          x = {"foo": 1, "bar": 2}
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          x = {}
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
  
      def test_copy_set(self):
          x = {1, 2, 3}
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          x = set()
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
  
      def test_copy_frozenset(self):
          x = frozenset({1, 2, 3})
          self.assertIs(copy.copy(x), x)
          x = frozenset()
          self.assertIs(copy.copy(x), x)
  
      def test_copy_bytearray(self):
          x = bytearray(b'abc')
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          x = bytearray()
          y = copy.copy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
  
      def test_copy_inst_vanilla(self):
          class C:
              def __init__(self, foo):
                  self.foo = foo
              def __eq__(self, other):
                  return 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 __eq__(self, other):
                  return 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 __eq__(self, other):
                  return self.foo == other.foo
          x = C(42)
          self.assertEqual(copy.copy(x), x)
  
      def test_copy_inst_getnewargs(self):
          class C(int):
              def __new__(cls, foo):
                  self = int.__new__(cls)
                  self.foo = foo
                  return self
              def __getnewargs__(self):
                  return self.foo,
              def __eq__(self, other):
                  return self.foo == other.foo
          x = C(42)
          y = copy.copy(x)
          self.assertIsInstance(y, C)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertEqual(y.foo, x.foo)
  
      def test_copy_inst_getnewargs_ex(self):
          class C(int):
              def __new__(cls, *, foo):
                  self = int.__new__(cls)
                  self.foo = foo
                  return self
              def __getnewargs_ex__(self):
                  return (), {'foo': self.foo}
              def __eq__(self, other):
                  return self.foo == other.foo
          x = C(foo=42)
          y = copy.copy(x)
          self.assertIsInstance(y, C)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertEqual(y.foo, x.foo)
  
      def test_copy_inst_getstate(self):
          class C:
              def __init__(self, foo):
                  self.foo = foo
              def __getstate__(self):
                  return {"foo": self.foo}
              def __eq__(self, other):
                  return 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 __eq__(self, other):
                  return 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 __eq__(self, other):
                  return self.foo == other.foo
          x = C(42)
          self.assertEqual(copy.copy(x), x)
          # State with boolean value is false (issue #25718)
          x = C(0.0)
          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.assertIsNot(y, x)
          self.assertIsNot(y[0], x[0])
          self.assertIs(y[0], 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):
              pass
          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)
          copyreg.pickle(C, pickle_C, C)
          y = copy.deepcopy(x)
  
      def test_deepcopy_reduce_ex(self):
          class C(object):
              def __reduce_ex__(self, proto):
                  c.append(1)
                  return ""
              def __reduce__(self):
                  self.fail("shouldn't call this")
          c = []
          x = C()
          y = copy.deepcopy(x)
          self.assertIs(y, x)
          self.assertEqual(c, [1])
  
      def test_deepcopy_reduce(self):
          class C(object):
              def __reduce__(self):
                  c.append(1)
                  return ""
          c = []
          x = C()
          y = copy.deepcopy(x)
          self.assertIs(y, x)
          self.assertEqual(c, [1])
  
      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, 2**100, 3.14, True, False, 1j,
                   "hello", "hello\u1234", f.__code__,
                   NewStyle, Classic, max]
          for x in tests:
              self.assertIs(copy.deepcopy(x), x)
  
      def test_deepcopy_list(self):
          x = [[1, 2], 3]
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(x, y)
          self.assertIsNot(x[0], y[0])
  
      def test_deepcopy_reflexive_list(self):
          x = []
          x.append(x)
          y = copy.deepcopy(x)
          if cosmo.MODE == "dbg": # requires recursion checking
              for op in comparisons:
                  self.assertRaises(RecursionError, op, y, x)
          self.assertIsNot(y, x)
          self.assertIs(y[0], y)
          self.assertEqual(len(y), 1)
  
      def test_deepcopy_empty_tuple(self):
          x = ()
          y = copy.deepcopy(x)
          self.assertIs(x, y)
  
      def test_deepcopy_tuple(self):
          x = ([1, 2], 3)
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(x, y)
          self.assertIsNot(x[0], y[0])
  
      def test_deepcopy_tuple_of_immutables(self):
          x = ((1, 2), 3)
          y = copy.deepcopy(x)
          self.assertIs(x, y)
  
      def test_deepcopy_reflexive_tuple(self):
          x = ([],)
          x[0].append(x)
          y = copy.deepcopy(x)
          if cosmo.MODE == "dbg": # requires recursion checking
              for op in comparisons:
                  self.assertRaises(RecursionError, op, y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y[0], x[0])
          self.assertIs(y[0][0], y)
  
      def test_deepcopy_dict(self):
          x = {"foo": [1, 2], "bar": 3}
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(x, y)
          self.assertIsNot(x["foo"], y["foo"])
  
      def test_deepcopy_reflexive_dict(self):
          x = {}
          x['foo'] = x
          y = copy.deepcopy(x)
          for op in order_comparisons:
              self.assertRaises(TypeError, op, y, x)
          if cosmo.MODE == "dbg": # requires recursion checking
              for op in equality_comparisons:
                  self.assertRaises(RecursionError, op, y, x)
          self.assertIsNot(y, x)
          self.assertIs(y['foo'], y)
          self.assertEqual(len(y), 1)
  
      def test_deepcopy_keepalive(self):
          memo = {}
          x = []
          y = copy.deepcopy(x, memo)
          self.assertIs(memo[id(memo)][0], x)
  
      def test_deepcopy_dont_memo_immutable(self):
          memo = {}
          x = [1, 2, 3, 4]
          y = copy.deepcopy(x, memo)
          self.assertEqual(y, x)
          # There's the entry for the new list, and the keep alive.
          self.assertEqual(len(memo), 2)
  
          memo = {}
          x = [(1, 2)]
          y = copy.deepcopy(x, memo)
          self.assertEqual(y, x)
          # Tuples with immutable contents are immutable for deepcopy.
          self.assertEqual(len(memo), 2)
  
      def test_deepcopy_inst_vanilla(self):
          class C:
              def __init__(self, foo):
                  self.foo = foo
              def __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y.foo, 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 __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y.foo, x.foo)
  
      def test_deepcopy_inst_getinitargs(self):
          class C:
              def __init__(self, foo):
                  self.foo = foo
              def __getinitargs__(self):
                  return (self.foo,)
              def __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y.foo, x.foo)
  
      def test_deepcopy_inst_getnewargs(self):
          class C(int):
              def __new__(cls, foo):
                  self = int.__new__(cls)
                  self.foo = foo
                  return self
              def __getnewargs__(self):
                  return self.foo,
              def __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertIsInstance(y, C)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertEqual(y.foo, x.foo)
          self.assertIsNot(y.foo, x.foo)
  
      def test_deepcopy_inst_getnewargs_ex(self):
          class C(int):
              def __new__(cls, *, foo):
                  self = int.__new__(cls)
                  self.foo = foo
                  return self
              def __getnewargs_ex__(self):
                  return (), {'foo': self.foo}
              def __eq__(self, other):
                  return self.foo == other.foo
          x = C(foo=[42])
          y = copy.deepcopy(x)
          self.assertIsInstance(y, C)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertEqual(y.foo, x.foo)
          self.assertIsNot(y.foo, 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 __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y.foo, 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 __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y.foo, 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 __eq__(self, other):
                  return self.foo == other.foo
          x = C([42])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y.foo, x.foo)
          # State with boolean value is false (issue #25718)
          x = C([])
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y, x)
          self.assertIsNot(y.foo, x.foo)
  
      def test_deepcopy_reflexive_inst(self):
          class C:
              pass
          x = C()
          x.foo = x
          y = copy.deepcopy(x)
          self.assertIsNot(y, x)
          self.assertIs(y.foo, y)
  
      def test_deepcopy_range(self):
          class I(int):
              pass
          x = range(I(10))
          y = copy.deepcopy(x)
          self.assertIsNot(y, x)
          self.assertEqual(y, x)
          self.assertIsNot(y.stop, x.stop)
          self.assertEqual(y.stop, x.stop)
          self.assertIsInstance(y.stop, I)
  
      # _reconstruct()
  
      def test_reconstruct_string(self):
          class C(object):
              def __reduce__(self):
                  return ""
          x = C()
          y = copy.copy(x)
          self.assertIs(y, x)
          y = copy.deepcopy(x)
          self.assertIs(y, x)
  
      def test_reconstruct_nostate(self):
          class C(object):
              def __reduce__(self):
                  return (C, ())
          x = C()
          x.foo = 42
          y = copy.copy(x)
          self.assertIs(y.__class__, x.__class__)
          y = copy.deepcopy(x)
          self.assertIs(y.__class__, x.__class__)
  
      def test_reconstruct_state(self):
          class C(object):
              def __reduce__(self):
                  return (C, (), self.__dict__)
              def __eq__(self, other):
                  return self.__dict__ == other.__dict__
          x = C()
          x.foo = [42]
          y = copy.copy(x)
          self.assertEqual(y, x)
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y.foo, 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 __eq__(self, other):
                  return self.__dict__ == other.__dict__
          x = C()
          x.foo = [42]
          y = copy.copy(x)
          self.assertEqual(y, x)
          y = copy.deepcopy(x)
          self.assertEqual(y, x)
          self.assertIsNot(y.foo, x.foo)
  
      def test_reconstruct_reflexive(self):
          class C(object):
              pass
          x = C()
          x.foo = x
          y = copy.deepcopy(x)
          self.assertIsNot(y, x)
          self.assertIs(y.foo, 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 __eq__(self, other):
                  return (list(self) == list(other) and
                          self.__dict__ == other.__dict__)
          x = C([[1, 2], 3])
          y = copy.copy(x)
          self.assertEqual(x, y)
          self.assertIsNot(x, y)
          self.assertIs(x[0], y[0])
          y = copy.deepcopy(x)
          self.assertEqual(x, y)
          self.assertIsNot(x, y)
          self.assertIsNot(x[0], y[0])
  
      def test_reduce_5tuple(self):
          class C(dict):
              def __reduce__(self):
                  return (C, (), self.__dict__, None, self.items())
              def __eq__(self, other):
                  return (dict(self) == dict(other) and
                          self.__dict__ == other.__dict__)
          x = C([("foo", [1, 2]), ("bar", 3)])
          y = copy.copy(x)
          self.assertEqual(x, y)
          self.assertIsNot(x, y)
          self.assertIs(x["foo"], y["foo"])
          y = copy.deepcopy(x)
          self.assertEqual(x, y)
          self.assertIsNot(x, y)
          self.assertIsNot(x["foo"], y["foo"])
  
      def test_copy_slots(self):
          class C(object):
              __slots__ = ["foo"]
          x = C()
          x.foo = [42]
          y = copy.copy(x)
          self.assertIs(x.foo, 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.assertIsNot(x.foo, 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())
                  super().__init__(d)
              def __setitem__(self, key, item):
                  super().__setitem__(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.assertIsNot(x, 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.assertIs(x[0], y[0])
          self.assertIs(x.foo, 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.assertIsNot(x[0], y[0])
          self.assertIsNot(x.foo, 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.assertIsNot(x, y)
          self.assertIsNot(x[0], 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.assertIs(y, x)
          del obj
          y = _copy(x)
          self.assertIs(y, 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 range(4)]
          u = _dicttype()
          u[a] = b
          u[c] = d
          v = copy.copy(u)
          self.assertIsNot(v, 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 range(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.assertIsNot(v[a], b)
          self.assertIsNot(v[c], 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 range(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.assertIsNot(x, a)
          self.assertEqual(x.i, a.i)
          self.assertIs(y, b)
          self.assertIsNot(z, c)
          self.assertEqual(z.i, c.i)
          self.assertIs(t, 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.assertIs(g.b.__self__, g)
          g.b()
  
  
  def global_foo(x, y): return x+y
  
  if __name__ == "__main__":
      unittest.main()
  