xref: /third_party/python/Lib/test/test_weakref.py

6 import weakref
113         wr = weakref.ref(o)
125         obj_weakref = weakref.ref(obj)
140         wr = weakref.ref(f)
149         ref1 = weakref.ref(o, self.callback)
150         ref2 = weakref.ref(o, self.callback)
172         self.ref = weakref.ref(c, callback)
173         ref1 = weakref.ref(c, callback)
178         self.assertRaises(TypeError, weakref.ref, c, callback=None)
183         ref1 = weakref.proxy(o, self.callback)
184         ref2 = weakref.proxy(o, self.callback)
193         ref3 = weakref.proxy(C())
200         ref = weakref.ref(o)
210         ref = weakref.ref(o, self.callback)
220         ref1 = weakref.ref(o)
223         proxy = weakref.proxy(o)
224         ref2 = weakref.ref(o)
229         proxy = weakref.proxy(o)
230         ref1 = weakref.ref(o)
231         ref2 = weakref.ref(o)
234         self.assertEqual(weakref.getweakrefcount(o), 2,
238         self.assertEqual(weakref.getweakrefcount(o), 1,
243         proxy1 = weakref.proxy(o)
244         ref = weakref.ref(o)
245         proxy2 = weakref.proxy(o)
251         self.check_proxy(o, weakref.proxy(o))
254         p = weakref.proxy(L)
267         p2 = weakref.proxy(L2)
271         p3 = weakref.proxy(L3)
285         self.assertIn("__bytes__", dir(weakref.proxy(instance)))
286         self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
293         p = weakref.proxy(o)
303         p = weakref.proxy(o)
317         p = weakref.proxy(o)
332         self.check_shared_without_callback(weakref.ref)
335         self.check_shared_without_callback(weakref.proxy)
357         ref1 = weakref.proxy(o)
361         self.assertIs(type(ref1), weakref.CallableProxyType,
404         f = weakref.proxy(g)
412         self.assertEqual(bool(weakref.proxy(lyst)), bool(lyst))
427         p = weakref.proxy(obj)
442                 return weakref.proxy(it)
457                 return weakref.proxy(not_an_iterator)
472         self.assertEqual("".join(reversed(weakref.proxy(obj))), "cba")
481             hash(weakref.proxy(obj))
488             hash(weakref.proxy(obj))
492         ref1 = weakref.ref(o)
493         ref2 = weakref.ref(o, self.callback)
494         self.assertEqual(weakref.getweakrefcount(o), 2,
497         proxy1 = weakref.proxy(o)
498         proxy2 = weakref.proxy(o, self.callback)
499         self.assertEqual(weakref.getweakrefcount(o), 4,
504         self.assertEqual(weakref.getweakrefcount(o), 0,
509         self.assertEqual(weakref.getweakrefcount(1), 0,
514         ref1 = weakref.ref(o, self.callback)
515         ref2 = weakref.ref(o, self.callback)
518         self.assertEqual(weakref.getweakrefs(o), [ref2],
522         ref1 = weakref.ref(o, self.callback)
523         ref2 = weakref.ref(o, self.callback)
526         self.assertEqual(weakref.getweakrefs(o), [ref1],
531         self.assertEqual(weakref.getweakrefs(o), [],
535         self.assertEqual(weakref.getweakrefs(1), [],
542         p = weakref.proxy(f)
556             data[weakref.ref(f, remove)] = None
572         # "weakref callbacks and gc corrupt memory"
575         # causing double-deallocation if the instance had a weakref
588         wr = weakref.ref(c, lambda ignore: gc.collect())
596         wr = weakref.ref(c1.i, lambda ignore: gc.collect())
603         # that c2 is immune from gc while the weakref callbacks associated
606         # so any gc triggered by weakref callbacks associated with anything
623         I.wr = weakref.ref(J, I.acallback)
628         # J.  I is also in a cycle (I.wr points to a weakref that references
643         # reference to J, which triggers the weakref callback.  The callback
670         c2.wr = weakref.ref(c1, c2.cb)
698         c2.wr = weakref.ref(c1, c2.cb)
706         # Do something nasty in a weakref callback:  resurrect objects
707         # from dead cycles.  For this to be attempted, the weakref and
726         c1.wr = weakref.ref(c2, c1.acallback)
727         c2.wr = weakref.ref(c1, c2.acallback)
731         wr = weakref.ref(C, C_went_away)
738         # been cleared without their callbacks executing.  OTOH, the weakref
742         # The remaining weakref should be dead now (its callback ran).
752         # Set up weakref callbacks *on* weakref callbacks.
765         c.wr = weakref.ref(d, callback)     # this won't trigger
766         d.wr = weakref.ref(callback, d.cb)  # ditto
767         external_wr = weakref.ref(callback, safe_callback)  # but this will
788         self.check_gc_during_creation(weakref.ref)
791         self.check_gc_during_creation(weakref.proxy)
813             weakref.ref(referenced, callback)
820         # A weakref created in an object's __del__() would crash the
821         # interpreter when the weakref was cleaned up since it would refer to
826                 ref_from_del = weakref.ref(self)
832         # <weakref to class>.__init__() doesn't check errors correctly
833         r = weakref.ref(Exception)
843         weakref.ref(int)
844         a = weakref.ref(A, l.append)
855         a = weakref.ref(x)
856         b = weakref.ref(y)
857         c = weakref.ref(z)
858         d = weakref.ref(x)
877         # same weakref object is an implementation detail, since they pointed
892         a = weakref.ref(x)
893         b = weakref.ref(y)
906         a = weakref.ref(x)
907         b = weakref.ref(y)
918         # Issue #16602: when a weakref's target was part of a long
920         # of the weakref and make the target object visible from outside
926                 wself = weakref.ref(self)
929                 self.wparent = weakref.ref(parent, cb)
931         d = weakref.WeakKeyDictionary()
941         ref1 = weakref.ref(x, callback)
944         ref2 = weakref.ref(x)
949         ref = weakref.ref(x, self.callback)
958         ref1 = weakref.ref(x, callback)
966         ref1 = weakref.ref(x, lambda ref: support.gc_collect())
974         class MyRef(weakref.ref):
992         class MyRef(weakref.ref):
996         r2 = weakref.ref(o)
998         self.assertEqual(weakref.getweakrefs(o), [r2, r1])
999         self.assertEqual(weakref.getweakrefcount(o), 2)
1001         self.assertEqual(weakref.getweakrefcount(o), 3)
1002         refs = weakref.getweakrefs(o)
1009         class MyRef(weakref.ref):
1015         refs = weakref.getweakrefs(o)
1020         class MyRef(weakref.ref):
1023                 return weakref.ref.__new__(type, ob, callback)
1038         # An instance of a weakref subclass can have attributes.
1039         # If such a weakref holds the only strong reference to the object,
1040         # deleting the weakref will delete the object. In this case,
1043         class MyRef(weakref.ref):
1086         r = weakref.WeakMethod(o.some_method)
1087         self.assertIsInstance(r, weakref.ReferenceType)
1095         r = weakref.WeakMethod(o.some_method)
1103         r = weakref.WeakMethod(o.some_method)
1115         r = weakref.WeakMethod(o.some_method, cb)
1131         r = weakref.WeakMethod(o.some_method, cb)
1146         r = weakref.WeakMethod(o.some_method, cb)
1147         wr = weakref.ref(r)
1160         a = weakref.WeakMethod(x.some_method)
1161         b = weakref.WeakMethod(y.some_method)
1162         c = weakref.WeakMethod(x.other_method)
1163         d = weakref.WeakMethod(y.other_method)
1174         e = weakref.WeakMethod(z.some_method)
1175         f = weakref.WeakMethod(z.other_method)
1197         a = weakref.WeakMethod(x.some_method)
1198         b = weakref.WeakMethod(y.some_method)
1199         c = weakref.WeakMethod(y.other_method)
1237         self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
1240         self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
1267         self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
1270         self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
1278             self.assertEqual(weakref.getweakrefcount(o), 1)
1298         dict = weakref.WeakValueDictionary()
1311             self.assertEqual(weakref.getweakrefcount(o), 1,
1429         # weakref'ed objects and then return a new key/value pair corresponding
1536         dict = weakref.WeakKeyDictionary({o:364})
1541         dict = weakref.WeakKeyDictionary({o:364})
1542         dict2 = weakref.WeakKeyDictionary(dict)
1546         dict = weakref.WeakKeyDictionary()
1554         dict = weakref.WeakValueDictionary({364:o})
1559         dict = weakref.WeakValueDictionary({364:o})
1560         dict2 = weakref.WeakValueDictionary(dict)
1565         self.assertRaises(TypeError, weakref.WeakValueDictionary.__init__)
1566         self.assertRaises(TypeError, weakref.WeakValueDictionary, {}, {})
1567         self.assertRaises(TypeError, weakref.WeakValueDictionary, (), ())
1571             d = weakref.WeakValueDictionary(**{kw: o})
1576         dict = weakref.WeakValueDictionary()
1601         self.check_popitem(weakref.WeakValueDictionary,
1605         self.check_popitem(weakref.WeakKeyDictionary,
1626         self.check_setdefault(weakref.WeakValueDictionary,
1630         self.check_setdefault(weakref.WeakKeyDictionary,
1653         self.check_update(weakref.WeakValueDictionary,
1656         self.assertRaises(TypeError, weakref.WeakValueDictionary.update)
1657         d = weakref.WeakValueDictionary()
1664             d = weakref.WeakValueDictionary()
1673         wvd1 = weakref.WeakValueDictionary({1: a})
1674         wvd2 = weakref.WeakValueDictionary({1: b, 2: a})
1681         self.assertIs(type(tmp1), weakref.WeakValueDictionary)
1687         self.assertIs(type(tmp2), weakref.WeakValueDictionary)
1694         self.assertIs(type(tmp3), weakref.WeakValueDictionary)
1698         self.assertIs(type(tmp4), weakref.WeakValueDictionary)
1707         self.check_update(weakref.WeakKeyDictionary,
1711         d = weakref.WeakKeyDictionary()
1725         wkd1 = weakref.WeakKeyDictionary({o1: 1, o2: 2})
1726         wkd2 = weakref.WeakKeyDictionary({o3: 3, o1: 4})
1733         self.assertIs(type(tmp1), weakref.WeakKeyDictionary)
1739         self.assertIs(type(tmp2), weakref.WeakKeyDictionary)
1746         self.assertIs(type(tmp3), weakref.WeakKeyDictionary)
1750         self.assertIs(type(tmp4), weakref.WeakKeyDictionary)
1759         d = weakref.WeakValueDictionary()
1770         d = weakref.WeakKeyDictionary()
1788         d = weakref.WeakKeyDictionary()
1830         dict = weakref.WeakValueDictionary()
1834         dict = weakref.WeakKeyDictionary()
1839         d = weakref.WeakValueDictionary()
1848         d = weakref.WeakValueDictionary()
1859         d = weakref.WeakValueDictionary()
1899         self.assertIn(type_, (weakref.WeakKeyDictionary, weakref.WeakValueDictionary))
1914         if type_ is weakref.WeakKeyDictionary:
1916         else:  # weakref.WeakValueDictionary
1933         self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, False)
1939         self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, True)
1945         self.check_threaded_weak_dict_copy(weakref.WeakValueDictionary, False)
1951         self.check_threaded_weak_dict_copy(weakref.WeakValueDictionary, True)
1955         d = weakref.WeakValueDictionary()
1964     type2test = weakref.WeakValueDictionary
1971     type2test = weakref.WeakKeyDictionary
1994         f = weakref.finalize(a, add, 67, 43, z=89)
2006         f = weakref.finalize(a, add, 67, 43, 89)
2017         f = weakref.finalize(a, add, x=67, y=43, z=89)
2034         f = weakref.finalize(a, fin, 1, 2, func=3, obj=4)
2040             weakref.finalize(a, func=fin, arg=1)
2042             weakref.finalize(obj=a, func=fin, arg=1)
2043         self.assertRaises(TypeError, weakref.finalize, a)
2044         self.assertRaises(TypeError, weakref.finalize)
2050         f1 = weakref.finalize(a, res.append, 'f1')
2051         f2 = weakref.finalize(a, res.append, 'f2')
2052         f3 = weakref.finalize(a, res.append, 'f3')
2053         f4 = weakref.finalize(a, res.append, 'f4')
2054         f5 = weakref.finalize(a, res.append, 'f5')
2086         # we want a weakrefable subclass of weakref.finalize
2087         class MyFinalizer(weakref.finalize):
2096         wr_callback = weakref.ref(callback)
2097         wr_f = weakref.ref(f)
2115             g1 = weakref.finalize(cls, print, 'g1')
2120         f1 = weakref.finalize(cls, print, 'f1', _global_var)
2121         f2 = weakref.finalize(cls, print, 'f2', _global_var)
2122         f3 = weakref.finalize(cls, error)
2123         f4 = weakref.finalize(cls, print, 'f4', _global_var)
2143             obj = getattr(weakref, name)
2145                 self.assertEqual(obj.__module__, 'weakref')
2150 libreftest = """ Doctest for examples in the library reference: weakref.rst
2153 >>> import weakref
2158 >>> r = weakref.ref(obj)
2162 >>> import weakref
2167 >>> r = weakref.ref(o)
2176 >>> import weakref
2177 >>> class ExtendedRef(weakref.ref):
2210 >>> import weakref
2211 >>> _id2obj_dict = weakref.WeakValueDictionary()

Indexes created Thu Nov 07 10:32:03 CST 2024