Lines Matching refs:self
27 def method(self):
34 def __call__(self, x):
35 self.bar = x
47 def __init__(self, arg):
48 self.arg = arg
49 def __repr__(self):
50 return "<Object %r>" % self.arg
51 def __eq__(self, other):
53 return self.arg == other.arg
55 def __lt__(self, other):
57 return self.arg < other.arg
59 def __hash__(self):
60 return hash(self.arg)
61 def some_method(self):
63 def other_method(self):
68 def __init__(self):
69 self.cycle = self
74 def setUp(self):
75 self.cbcalled = 0
77 def callback(self, ref):
78 self.cbcalled += 1
105 def test_basic_ref(self):
106 self.check_basic_ref(C)
107 self.check_basic_ref(create_function)
108 self.check_basic_ref(create_bound_method)
119 def test_repr_failure_gh99184(self):
121 def __getattr__(self, x):
122 return self[x]
127 self.assertIn('MyConfig', repr(obj_weakref))
128 self.assertIn('MyConfig', str(obj_weakref))
130 def test_basic_callback(self):
131 self.check_basic_callback(C)
132 self.check_basic_callback(create_function)
133 self.check_basic_callback(create_bound_method)
136 def test_cfunction(self):
141 self.assertIs(wr(), f)
143 self.assertIsNone(wr())
144 self.check_basic_ref(create_cfunction)
145 self.check_basic_callback(create_cfunction)
147 def test_multiple_callbacks(self):
149 ref1 = weakref.ref(o, self.callback)
150 ref2 = weakref.ref(o, self.callback)
153 self.assertIsNone(ref1(), "expected reference to be invalidated")
154 self.assertIsNone(ref2(), "expected reference to be invalidated")
155 self.assertEqual(self.cbcalled, 2,
158 def test_multiple_selfref_callbacks(self):
169 def callback(object, self=self):
170 self.ref()
172 self.ref = weakref.ref(c, callback)
176 def test_constructor_kwargs(self):
178 self.assertRaises(TypeError, weakref.ref, c, callback=None)
180 def test_proxy_ref(self):
183 ref1 = weakref.proxy(o, self.callback)
184 ref2 = weakref.proxy(o, self.callback)
191 self.assertRaises(ReferenceError, check, ref1)
192 self.assertRaises(ReferenceError, check, ref2)
195 self.assertRaises(ReferenceError, bool, ref3)
196 self.assertEqual(self.cbcalled, 2)
198 def check_basic_ref(self, factory):
201 self.assertIsNotNone(ref(),
204 self.assertIs(o, o2,
207 def check_basic_callback(self, factory):
208 self.cbcalled = 0
210 ref = weakref.ref(o, self.callback)
213 self.assertEqual(self.cbcalled, 1,
215 self.assertIsNone(ref(),
218 def test_ref_reuse(self):
225 self.assertIs(ref1, ref2,
232 self.assertIs(ref1, ref2,
234 self.assertEqual(weakref.getweakrefcount(o), 2,
238 self.assertEqual(weakref.getweakrefcount(o), 1,
241 def test_proxy_reuse(self):
246 self.assertIs(proxy1, proxy2,
249 def test_basic_proxy(self):
251 self.check_proxy(o, weakref.proxy(o))
255 self.assertFalse(p, "proxy for empty UserList should be false")
257 self.assertEqual(len(L), 1)
258 self.assertTrue(p, "proxy for non-empty UserList should be true")
260 self.assertEqual(len(L), 2)
261 self.assertEqual(len(p), 2)
262 self.assertIn(3, p, "proxy didn't support __contains__() properly")
264 self.assertEqual(L[1], 5)
265 self.assertEqual(p[1], 5)
268 self.assertEqual(p, p2)
269 ## self.assertEqual(repr(L2), repr(p2))
272 self.assertEqual(L3[:], p3[:])
273 self.assertEqual(L3[5:], p3[5:])
274 self.assertEqual(L3[:5], p3[:5])
275 self.assertEqual(L3[2:5], p3[2:5])
277 def test_proxy_unicode(self):
280 def __str__(self):
282 def __bytes__(self):
285 self.assertIn("__bytes__", dir(weakref.proxy(instance)))
286 self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
288 def test_proxy_index(self):
290 def __index__(self):
294 self.assertEqual(operator.index(p), 10)
296 def test_proxy_div(self):
298 def __floordiv__(self, other):
300 def __ifloordiv__(self, other):
304 self.assertEqual(p // 5, 42)
306 self.assertEqual(p, 21)
308 def test_proxy_matmul(self):
310 def __matmul__(self, other):
312 def __rmatmul__(self, other):
314 def __imatmul__(self, other):
318 self.assertEqual(p @ 5, 1729)
319 self.assertEqual(5 @ p, -163)
321 self.assertEqual(p, 561)
331 def test_shared_ref_without_callback(self):
332 self.check_shared_without_callback(weakref.ref)
334 def test_shared_proxy_without_callback(self):
335 self.check_shared_without_callback(weakref.proxy)
337 def check_shared_without_callback(self, makeref):
341 self.assertIs(p1, p2, "both callbacks were None in the C API")
345 self.assertIs(p1, p2, "callbacks were NULL, None in the C API")
349 self.assertIs(p1, p2, "both callbacks were NULL in the C API")
353 self.assertIs(p1, p2, "callbacks were None, NULL in the C API")
355 def test_callable_proxy(self):
359 self.check_proxy(o, ref1)
361 self.assertIs(type(ref1), weakref.CallableProxyType,
364 self.assertEqual(o.bar, 'twinkies!',
367 self.assertEqual(o.bar, 'Splat.',
371 self.assertRaises(TypeError, ref1)
374 self.assertRaises(TypeError, ref1, 1, 2, 3)
376 def check_proxy(self, o, proxy):
378 self.assertEqual(proxy.foo, 1,
381 self.assertEqual(proxy.foo, 2,
384 self.assertFalse(hasattr(proxy, 'foo'),
388 self.assertEqual(o.foo, 1,
391 self.assertEqual(o.foo, 2,
394 self.assertFalse(hasattr(o, 'foo'),
397 def test_proxy_deletion(self):
401 def __delitem__(self, accessor):
402 self.result = accessor
406 self.assertEqual(f.result, 0)
408 def test_proxy_bool(self):
412 self.assertEqual(bool(weakref.proxy(lyst)), bool(lyst))
414 def test_proxy_iter(self):
421 def __iter__(self):
428 with self.assertRaises(TypeError):
434 def test_proxy_next(self):
441 def __iter__(self):
447 self.assertEqual(list(weak_it), [4, 5, 6])
449 def test_proxy_bad_next(self):
456 def __iter__(self):
461 with self.assertRaisesRegex(TypeError, msg):
464 def test_proxy_reversed(self):
466 def __len__(self):
468 def __reversed__(self):
472 self.assertEqual("".join(reversed(weakref.proxy(obj))), "cba")
474 def test_proxy_hash(self):
476 def __hash__(self):
480 with self.assertRaises(TypeError):
487 with self.assertRaises(TypeError):
490 def test_getweakrefcount(self):
493 ref2 = weakref.ref(o, self.callback)
494 self.assertEqual(weakref.getweakrefcount(o), 2,
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,
512 def test_getweakrefs(self):
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), [],
538 def test_newstyle_number_ops(self):
543 self.assertEqual(p + 1.0, 3.0)
544 self.assertEqual(1.0 + p, 3.0) # this used to SEGV
546 def test_callbacks_protected(self):
563 self.fail("exception not properly restored")
569 self.fail("exception not properly restored")
571 def test_sf_bug_840829(self):
611 def test_callback_in_cycle(self):
618 def acallback(self, ignore):
619 self.J
625 # Now J and II are each in a self-cycle (as all new-style class
639 # tp_clear on J breaks its self-cycle, but J doesn't get deleted
644 # tries to do "self.J", and instances of new-style classes look up
651 def test_callback_reachable_one_way(self):
661 def cb(self, ignore):
662 self.me
663 self.c1
664 self.wr
675 def test_callback_different_classes(self):
683 # tried to look up self.me).
686 def cb(self, ignore):
687 self.me
688 self.c1
689 self.wr
703 def test_callback_in_cycle_resurrection(self):
717 def __init__(self, value):
718 self.attribute = value
720 def acallback(self, ignore):
721 alist.append(self.c)
734 self.assertEqual(alist, []) # del isn't enough to reclaim anything
741 self.assertEqual(alist, ["C went away"])
743 self.assertEqual(wr(), None)
747 self.assertEqual(alist, [])
749 def test_callbacks_on_callback(self):
758 def cb(self, ignore):
768 self.assertIs(external_wr(), callback)
778 self.assertEqual(alist, []) # del isn't enough to clean up cycles
780 self.assertEqual(alist, ["safe_callback called"])
781 self.assertEqual(external_wr(), None)
785 self.assertEqual(alist, [])
787 def test_gc_during_ref_creation(self):
788 self.check_gc_during_creation(weakref.ref)
790 def test_gc_during_proxy_creation(self):
791 self.check_gc_during_creation(weakref.proxy)
793 def check_gc_during_creation(self, makeref):
818 def test_ref_created_during_del(self):
824 def __del__(self):
826 ref_from_del = weakref.ref(self)
830 def test_init(self):
834 self.assertRaises(TypeError, r.__init__, 0, 0, 0, 0, 0)
838 def test_classes(self):
847 self.assertEqual(a(), None)
848 self.assertEqual(l, [a])
850 def test_equality(self):
861 self.assertTrue(a == b)
862 self.assertFalse(a != b)
863 self.assertFalse(a == c)
864 self.assertTrue(a != c)
865 self.assertTrue(a == d)
866 self.assertFalse(a != d)
867 self.assertFalse(a == x)
868 self.assertTrue(a != x)
869 self.assertTrue(a == ALWAYS_EQ)
870 self.assertFalse(a != ALWAYS_EQ)
875 self.assertIs(r(), None)
880 self.assertFalse(a == b)
881 self.assertTrue(a != b)
882 self.assertFalse(a == c)
883 self.assertTrue(a != c)
884 self.assertEqual(a == d, a is d)
885 self.assertEqual(a != d, a is not d)
887 def test_ordering(self):
895 self.assertRaises(TypeError, op, a, b)
900 self.assertRaises(TypeError, op, a, b)
902 def test_hashing(self):
908 self.assertEqual(hash(a), hash(42))
914 self.assertEqual(hash(a), hash(42))
915 self.assertRaises(TypeError, hash, b)
917 def test_trashcan_16602(self):
923 def __init__(self, parent):
926 wself = weakref.ref(self)
929 self.wparent = weakref.ref(parent, cb)
938 def test_callback_attribute(self):
942 self.assertIs(ref1.__callback__, callback)
945 self.assertIsNone(ref2.__callback__)
947 def test_callback_attribute_after_deletion(self):
949 ref = weakref.ref(x, self.callback)
950 self.assertIsNotNone(ref.__callback__)
953 self.assertIsNone(ref.__callback__)
955 def test_set_callback_attribute(self):
959 with self.assertRaises(AttributeError):
962 def test_callback_gcs(self):
964 def __del__(self): pass
973 def test_subclass_refs(self):
975 def __init__(self, ob, callback=None, value=42):
976 self.value = value
978 def __call__(self):
979 self.called = True
983 self.assertIs(mr(), o)
984 self.assertTrue(mr.called)
985 self.assertEqual(mr.value, 24)
988 self.assertIsNone(mr())
989 self.assertTrue(mr.called)
991 def test_subclass_refs_dont_replace_standard_refs(self):
997 self.assertIsNot(r1, r2)
998 self.assertEqual(weakref.getweakrefs(o), [r2, r1])
999 self.assertEqual(weakref.getweakrefcount(o), 2)
1001 self.assertEqual(weakref.getweakrefcount(o), 3)
1003 self.assertEqual(len(refs), 3)
1004 self.assertIs(r2, refs[0])
1005 self.assertIn(r1, refs[1:])
1006 self.assertIn(r3, refs[1:])
1008 def test_subclass_refs_dont_conflate_callbacks(self):
1014 self.assertIsNot(r1, r2)
1016 self.assertIn(r1, refs)
1017 self.assertIn(r2, refs)
1019 def test_subclass_refs_with_slots(self):
1024 def __init__(self, ob, callback, slot1, slot2):
1025 self.slot1 = slot1
1026 self.slot2 = slot2
1027 def meth(self):
1028 return self.slot1 + self.slot2
1031 self.assertEqual(r.slot1, "abc")
1032 self.assertEqual(r.slot2, "def")
1033 self.assertEqual(r.meth(), "abcdef")
1034 self.assertFalse(hasattr(r, "__dict__"))
1036 def test_subclass_refs_with_cycle(self):
1049 self.cbcalled += 1
1058 self.assertEqual(self.cbcalled, 0)
1072 self.assertEqual(self.cbcalled, 0)
1077 def _subclass(self):
1080 def some_method(self):
1084 def test_alive(self):
1087 self.assertIsInstance(r, weakref.ReferenceType)
1088 self.assertIsInstance(r(), type(o.some_method))
1089 self.assertIs(r().__self__, o)
1090 self.assertIs(r().__func__, o.some_method.__func__)
1091 self.assertEqual(r()(), 4)
1093 def test_object_dead(self):
1098 self.assertIs(r(), None)
1100 def test_method_dead(self):
1101 C = self._subclass()
1106 self.assertIs(r(), None)
1108 def test_callback_when_object_dead(self):
1110 C = self._subclass()
1118 self.assertEqual(calls, [r])
1122 self.assertEqual(calls, [r])
1124 def test_callback_when_method_dead(self):
1126 C = self._subclass()
1134 self.assertEqual(calls, [r])
1138 self.assertEqual(calls, [r])
1141 def test_no_cycles(self):
1149 self.assertIs(wr(), None)
1151 def test_equality(self):
1153 self.assertTrue(a == b)
1154 self.assertFalse(a != b)
1156 self.assertTrue(a != b)
1157 self.assertFalse(a == b)
1189 self.assertEqual(q == r, q is r)
1190 self.assertEqual(q != r, q is not r)
1192 def test_hashing(self):
1201 self.assertEqual(hash(a), hash(b))
1206 self.assertEqual(hash(a), ha)
1207 self.assertEqual(hash(b), ha)
1209 self.assertRaises(TypeError, hash, c)
1216 def check_len_cycles(self, dict_type, cons):
1233 self.assertIn(n1, (0, 1))
1234 self.assertEqual(n2, 0)
1236 def test_weak_keyed_len_cycles(self):
1237 self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
1239 def test_weak_valued_len_cycles(self):
1240 self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
1242 def check_len_race(self, dict_type, cons):
1244 self.addCleanup(gc.set_threshold, *gc.get_threshold())
1261 self.assertGreaterEqual(n1, 0)
1262 self.assertLessEqual(n1, N)
1263 self.assertGreaterEqual(n2, 0)
1264 self.assertLessEqual(n2, n1)
1266 def test_weak_keyed_len_race(self):
1267 self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
1269 def test_weak_valued_len_race(self):
1270 self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
1272 def test_weak_values(self):
1276 dict, objects = self.make_weak_valued_dict()
1278 self.assertEqual(weakref.getweakrefcount(o), 1)
1279 self.assertIs(o, dict[o.arg],
1285 self.assertEqual(items1, items2,
1288 self.assertEqual(len(dict), self.COUNT)
1291 self.assertEqual(len(dict), self.COUNT - 1,
1295 self.assertEqual(len(dict), 0,
1299 self.assertRaises(KeyError, dict.__getitem__, 1)
1302 self.assertRaises(KeyError, dict.__getitem__, 2)
1304 def test_weak_keys(self):
1309 dict, objects = self.make_weak_keyed_dict()
1311 self.assertEqual(weakref.getweakrefcount(o), 1,
1313 self.assertIs(o.arg, dict[o],
1317 self.assertEqual(set(items1), set(items2),
1320 self.assertEqual(len(dict), self.COUNT)
1323 self.assertEqual(len(dict), (self.COUNT - 1),
1327 self.assertEqual(len(dict), 0,
1331 self.assertIn(o, dict)
1332 self.assertNotIn(34, dict)
1334 def test_weak_keyed_iters(self):
1335 dict, objects = self.make_weak_keyed_dict()
1336 self.check_iters(dict)
1340 self.assertEqual(len(refs), len(objects))
1344 self.assertIn(ob, dict)
1345 self.assertIn(ob, dict)
1346 self.assertEqual(ob.arg, dict[ob])
1348 self.assertEqual(len(objects2), 0)
1352 self.assertEqual(len(list(dict.keyrefs())), len(objects))
1355 self.assertIn(ob, dict)
1356 self.assertIn(ob, dict)
1357 self.assertEqual(ob.arg, dict[ob])
1359 self.assertEqual(len(objects2), 0)
1361 def test_weak_valued_iters(self):
1362 dict, objects = self.make_weak_valued_dict()
1363 self.check_iters(dict)
1367 self.assertEqual(len(refs), len(objects))
1371 self.assertEqual(ob, dict[ob.arg])
1372 self.assertEqual(ob.arg, dict[ob.arg].arg)
1374 self.assertEqual(len(objects2), 0)
1378 self.assertEqual(len(list(dict.itervaluerefs())), len(objects))
1381 self.assertEqual(ob, dict[ob.arg])
1382 self.assertEqual(ob.arg, dict[ob.arg].arg)
1384 self.assertEqual(len(objects2), 0)
1386 def check_iters(self, dict):
1391 self.assertFalse(items, "items() did not touch all items")
1397 self.assertFalse(keys, "__iter__() did not touch all keys")
1403 self.assertFalse(keys, "iterkeys() did not touch all keys")
1409 self.assertFalse(values,
1412 def check_weak_destroy_while_iterating(self, dict, objects, iter_name):
1420 self.assertIn(len(list(it)), [len(objects), len(objects) - 1])
1423 self.assertEqual(len(dict), n - 1)
1425 def check_weak_destroy_and_mutate_while_iterating(self, dict, testcontext):
1432 self.assertNotIn(k, dict)
1434 self.assertRaises(KeyError, dict.__delitem__, k)
1435 self.assertNotIn(k, dict)
1437 self.assertRaises(KeyError, dict.pop, k)
1438 self.assertNotIn(k, dict)
1441 self.assertEqual(dict[k], v)
1445 self.assertEqual(dict, ddict)
1448 self.assertEqual(len(dict), 0)
1450 def check_weak_del_and_len_while_iterating(self, dict, testcontext):
1461 self.assertEqual(len(dict), n - 1)
1463 self.assertEqual(len(dict), n)
1466 self.assertEqual(len(dict), n - 1)
1469 self.assertEqual(len(dict), n - 2)
1471 self.assertEqual(len(dict), n - 3)
1473 self.assertEqual(len(dict), n - 4)
1475 self.assertEqual(len(dict), n - 5)
1477 self.assertEqual(len(dict), n - 6)
1480 self.assertEqual(len(dict), 0)
1481 self.assertEqual(len(dict), 0)
1483 def test_weak_keys_destroy_while_iterating(self):
1485 dict, objects = self.make_weak_keyed_dict()
1486 self.check_weak_destroy_while_iterating(dict, objects, 'keys')
1487 self.check_weak_destroy_while_iterating(dict, objects, 'items')
1488 self.check_weak_destroy_while_iterating(dict, objects, 'values')
1489 self.check_weak_destroy_while_iterating(dict, objects, 'keyrefs')
1490 dict, objects = self.make_weak_keyed_dict()
1503 self.check_weak_destroy_and_mutate_while_iterating(dict, testcontext)
1506 dict, objects = self.make_weak_keyed_dict()
1507 self.check_weak_del_and_len_while_iterating(dict, testcontext)
1509 def test_weak_values_destroy_while_iterating(self):
1511 dict, objects = self.make_weak_valued_dict()
1512 self.check_weak_destroy_while_iterating(dict, objects, 'keys')
1513 self.check_weak_destroy_while_iterating(dict, objects, 'items')
1514 self.check_weak_destroy_while_iterating(dict, objects, 'values')
1515 self.check_weak_destroy_while_iterating(dict, objects, 'itervaluerefs')
1516 self.check_weak_destroy_while_iterating(dict, objects, 'valuerefs')
1517 dict, objects = self.make_weak_valued_dict()
1530 self.check_weak_destroy_and_mutate_while_iterating(dict, testcontext)
1531 dict, objects = self.make_weak_valued_dict()
1532 self.check_weak_del_and_len_while_iterating(dict, testcontext)
1534 def test_make_weak_keyed_dict_from_dict(self):
1537 self.assertEqual(dict[o], 364)
1539 def test_make_weak_keyed_dict_from_weak_keyed_dict(self):
1543 self.assertEqual(dict[o], 364)
1545 def make_weak_keyed_dict(self):
1547 objects = list(map(Object, range(self.COUNT)))
1552 def test_make_weak_valued_dict_from_dict(self):
1555 self.assertEqual(dict[364], o)
1557 def test_make_weak_valued_dict_from_weak_valued_dict(self):
1561 self.assertEqual(dict[364], o)
1563 def test_make_weak_valued_dict_misc(self):
1565 self.assertRaises(TypeError, weakref.WeakValueDictionary.__init__)
1566 self.assertRaises(TypeError, weakref.WeakValueDictionary, {}, {})
1567 self.assertRaises(TypeError, weakref.WeakValueDictionary, (), ())
1570 for kw in 'self', 'dict', 'other', 'iterable':
1572 self.assertEqual(list(d.keys()), [kw])
1573 self.assertEqual(d[kw], o)
1575 def make_weak_valued_dict(self):
1577 objects = list(map(Object, range(self.COUNT)))
1582 def check_popitem(self, klass, key1, value1, key2, value2):
1586 self.assertEqual(len(weakdict), 2)
1588 self.assertEqual(len(weakdict), 1)
1590 self.assertIs(v, value1)
1592 self.assertIs(v, value2)
1594 self.assertEqual(len(weakdict), 0)
1596 self.assertIs(v, value1)
1598 self.assertIs(v, value2)
1600 def test_weak_valued_dict_popitem(self):
1601 self.check_popitem(weakref.WeakValueDictionary,
1604 def test_weak_keyed_dict_popitem(self):
1605 self.check_popitem(weakref.WeakKeyDictionary,
1608 def check_setdefault(self, klass, key, value1, value2):
1609 self.assertIsNot(value1, value2,
1614 self.assertIs(o, value1)
1615 self.assertIn(key, weakdict)
1616 self.assertIs(weakdict.get(key), value1)
1617 self.assertIs(weakdict[key], value1)
1620 self.assertIs(o, value1)
1621 self.assertIn(key, weakdict)
1622 self.assertIs(weakdict.get(key), value1)
1623 self.assertIs(weakdict[key], value1)
1625 def test_weak_valued_dict_setdefault(self):
1626 self.check_setdefault(weakref.WeakValueDictionary,
1629 def test_weak_keyed_dict_setdefault(self):
1630 self.check_setdefault(weakref.WeakKeyDictionary,
1633 def check_update(self, klass, dict):
1640 self.assertEqual(len(weakdict), len(dict))
1642 self.assertIn(k, dict, "mysterious new key appeared in weak dict")
1644 self.assertIs(v, weakdict[k])
1645 self.assertIs(v, weakdict.get(k))
1647 self.assertIn(k, weakdict, "original key disappeared in weak dict")
1649 self.assertIs(v, weakdict[k])
1650 self.assertIs(v, weakdict.get(k))
1652 def test_weak_valued_dict_update(self):
1653 self.check_update(weakref.WeakValueDictionary,
1656 self.assertRaises(TypeError, weakref.WeakValueDictionary.update)
1658 self.assertRaises(TypeError, d.update, {}, {})
1659 self.assertRaises(TypeError, d.update, (), ())
1660 self.assertEqual(list(d.keys()), [])
1663 for kw in 'self', 'dict', 'other', 'iterable':
1666 self.assertEqual(list(d.keys()), [kw])
1667 self.assertEqual(d[kw], o)
1669 def test_weak_valued_union_operators(self):
1680 self.assertEqual(dict(tmp1), dict(wvd1) | dict(wvd2))
1681 self.assertIs(type(tmp1), weakref.WeakValueDictionary)
1683 self.assertEqual(wvd1, tmp1)
1686 self.assertEqual(dict(tmp2), dict(wvd2) | d1)
1687 self.assertIs(type(tmp2), weakref.WeakValueDictionary)
1689 self.assertEqual(wvd2, tmp2)
1693 self.assertEqual(dict(tmp3), dict(wvd3) | dict(pairs))
1694 self.assertIs(type(tmp3), weakref.WeakValueDictionary)
1697 self.assertEqual(dict(tmp4), d1 | dict(wvd3))
1698 self.assertIs(type(tmp4), weakref.WeakValueDictionary)
1701 self.assertNotIn(2, tmp1)
1702 self.assertNotIn(2, tmp2)
1703 self.assertNotIn(1, tmp3)
1704 self.assertNotIn(1, tmp4)
1706 def test_weak_keyed_dict_update(self):
1707 self.check_update(weakref.WeakKeyDictionary,
1710 def test_weak_keyed_delitem(self):
1716 self.assertEqual(len(d), 2)
1718 self.assertEqual(len(d), 1)
1719 self.assertEqual(list(d.keys()), [o2])
1721 def test_weak_keyed_union_operators(self):
1732 self.assertEqual(dict(tmp1), dict(wkd1) | dict(wkd2))
1733 self.assertIs(type(tmp1), weakref.WeakKeyDictionary)
1735 self.assertEqual(wkd1, tmp1)
1738 self.assertEqual(dict(tmp2), dict(wkd2) | d1)
1739 self.assertIs(type(tmp2), weakref.WeakKeyDictionary)
1741 self.assertEqual(wkd2, tmp2)
1745 self.assertEqual(dict(tmp3), dict(wkd3) | dict(pairs))
1746 self.assertIs(type(tmp3), weakref.WeakKeyDictionary)
1749 self.assertEqual(dict(tmp4), d1 | dict(wkd3))
1750 self.assertIs(type(tmp4), weakref.WeakKeyDictionary)
1753 self.assertNotIn(4, tmp1.values())
1754 self.assertNotIn(4, tmp2.values())
1755 self.assertNotIn(1, tmp3.values())
1756 self.assertNotIn(1, tmp4.values())
1758 def test_weak_valued_delitem(self):
1764 self.assertEqual(len(d), 2)
1766 self.assertEqual(len(d), 1)
1767 self.assertEqual(list(d.items()), [('something else', o2)])
1769 def test_weak_keyed_bad_delitem(self):
1774 self.assertRaises(KeyError, d.__delitem__, o)
1775 self.assertRaises(KeyError, d.__getitem__, o)
1779 self.assertRaises(TypeError, d.__delitem__, 13)
1780 self.assertRaises(TypeError, d.__getitem__, 13)
1781 self.assertRaises(TypeError, d.__setitem__, 13, 13)
1783 def test_weak_keyed_cascading_deletes(self):
1785 # over the keys via self.data.iterkeys(). If things vanished from
1792 def __init__(self, i):
1793 self.value = i
1794 def __hash__(self):
1795 return hash(self.value)
1796 def __eq__(self, other):
1801 return self.value == other.value
1826 self.assertEqual(len(d), 0)
1827 self.assertEqual(count, 2)
1829 def test_make_weak_valued_dict_repr(self):
1831 self.assertRegex(repr(dict), '<WeakValueDictionary at 0x.*>')
1833 def test_make_weak_keyed_dict_repr(self):
1835 self.assertRegex(repr(dict), '<WeakKeyDictionary at 0x.*>')
1838 def test_threaded_weak_valued_setdefault(self):
1843 self.assertIsNot(x, None) # we never put None in there!
1847 def test_threaded_weak_valued_pop(self):
1853 self.assertIsNot(x, None) # we never put None in there!
1856 def test_threaded_weak_valued_consistency(self):
1865 self.assertEqual(len(d), 1)
1868 def check_threaded_weak_dict_copy(self, type_, deepcopy):
1874 def __init__(self, ctr):
1875 self.ctr = ctr
1878 def __init__(self, ctr):
1879 self.ctr = ctr
1899 self.assertIn(type_, (weakref.WeakKeyDictionary, weakref.WeakValueDictionary))
1930 def test_threaded_weak_key_dict_copy(self):
1933 self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, False)
1936 def test_threaded_weak_key_dict_deepcopy(self):
1939 self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, True)
1942 def test_threaded_weak_value_dict_copy(self):
1945 self.check_threaded_weak_dict_copy(weakref.WeakValueDictionary, False)
1948 def test_threaded_weak_value_dict_deepcopy(self):
1951 self.check_threaded_weak_dict_copy(weakref.WeakValueDictionary, True)
1954 def test_remove_closure(self):
1956 self.assertIsNone(d._remove.__closure__)
1965 def _reference(self):
1966 return self.__ref.copy()
1972 def _reference(self):
1973 return self.__ref.copy()
1981 def _collect_if_necessary(self):
1986 def test_finalize(self):
1991 a = self.A()
1995 self.assertEqual(f.alive, True)
1996 self.assertEqual(f.peek(), (a, add, (67,43), {'z':89}))
1997 self.assertEqual(f(), 199)
1998 self.assertEqual(f(), None)
1999 self.assertEqual(f(), None)
2000 self.assertEqual(f.peek(), None)
2001 self.assertEqual(f.detach(), None)
2002 self.assertEqual(f.alive, False)
2003 self.assertEqual(res, [199])
2007 self.assertEqual(f.peek(), (a, add, (67,43,89), {}))
2008 self.assertEqual(f.detach(), (a, add, (67,43,89), {}))
2009 self.assertEqual(f(), None)
2010 self.assertEqual(f(), None)
2011 self.assertEqual(f.peek(), None)
2012 self.assertEqual(f.detach(), None)
2013 self.assertEqual(f.alive, False)
2014 self.assertEqual(res, [])
2019 self._collect_if_necessary()
2020 self.assertEqual(f(), None)
2021 self.assertEqual(f(), None)
2022 self.assertEqual(f.peek(), None)
2023 self.assertEqual(f.detach(), None)
2024 self.assertEqual(f.alive, False)
2025 self.assertEqual(res, [199])
2027 def test_arg_errors(self):
2031 a = self.A()
2035 self.assertEqual(f.peek(), (a, fin, (1, 2), {'func': 3, 'obj': 4}))
2037 self.assertEqual(res, [((1, 2), {'func': 3, 'obj': 4})])
2039 with self.assertRaises(TypeError):
2041 with self.assertRaises(TypeError):
2043 self.assertRaises(TypeError, weakref.finalize, a)
2044 self.assertRaises(TypeError, weakref.finalize)
2046 def test_order(self):
2047 a = self.A()
2059 self.assertTrue(f2.alive)
2060 self.assertTrue(f3.alive)
2061 self.assertTrue(f5.alive)
2063 self.assertTrue(f5.detach())
2064 self.assertFalse(f5.alive)
2069 self.assertFalse(f3.alive)
2074 self._collect_if_necessary()
2078 self.assertFalse(f2.alive)
2083 self.assertEqual(res, expected)
2085 def test_all_freed(self):
2090 a = self.A()
2100 self.assertIsNotNone(wr_callback())
2101 self.assertIsNotNone(wr_f())
2104 self._collect_if_necessary()
2106 self.assertIsNone(wr_callback())
2107 self.assertIsNone(wr_f())
2108 self.assertEqual(res, [123])
2130 def test_atexit(self):
2135 self.assertEqual(out, ['f4 foobar', 'f3 error', 'g1', 'f1 foobar'])
2136 self.assertTrue(b'ZeroDivisionError' in err)
2140 def test_names(self):
2145 self.assertEqual(obj.__module__, 'weakref')
2146 self.assertEqual(obj.__name__, name)
2147 self.assertEqual(obj.__qualname__, name)
2178 ... def __init__(self, ob, callback=None, **annotations):
2180 ... self.__counter = 0
2182 ... setattr(self, k, v)
2183 ... def __call__(self):
2189 ... self.__counter += 1
2190 ... ob = (ob, self.__counter)