cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_weakref.py @ 79675:c0a2294de787 2.7

Issue #16199: Backport 2to3 typo fix from 3.2.

author	Chris Jerdonek <chris.jerdonek@gmail.com>
date	Thu, 11 Oct 2012 16:15:46 -0700
parents	b6acfbe2bdbe
children	13b74c0b040c

rev	line source
31454 d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	1 import gc
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	2 import sys
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	3 import unittest
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	4 import UserList
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	5 import weakref
47196 12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	6 import operator
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	7
24364 aa0d2d51fbde Get rid of relative imports in all unittests. Now anything that Barry Warsaw <barry@python.org> parents: 23764 diff changeset	8 from test import test_support
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	9
40705 293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	10 # Used in ReferencesTestCase.test_ref_created_during_del() .
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	11 ref_from_del = None
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	12
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	13 class C:
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	14 def method(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	15 pass
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	16
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	17
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	18 class Callable:
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	19 bar = None
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	20
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	21 def __call__(self, x):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	22 self.bar = x
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	23
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	24
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	25 def create_function():
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	26 def f(): pass
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	27 return f
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	28
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	29 def create_bound_method():
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	30 return C().method
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	31
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	32 def create_unbound_method():
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	33 return C.method
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	34
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	35
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	36 class TestBase(unittest.TestCase):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	37
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	38 def setUp(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	39 self.cbcalled = 0
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	40
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	41 def callback(self, ref):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	42 self.cbcalled += 1
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	43
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	44
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	45 class ReferencesTestCase(TestBase):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	46
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	47 def test_basic_ref(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	48 self.check_basic_ref(C)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	49 self.check_basic_ref(create_function)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	50 self.check_basic_ref(create_bound_method)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	51 self.check_basic_ref(create_unbound_method)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	52
22946 cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	53 # Just make sure the tp_repr handler doesn't raise an exception.
cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	54 # Live reference:
cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	55 o = C()
cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	56 wr = weakref.ref(o)
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	57 repr(wr)
22946 cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	58 # Dead reference:
cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	59 del o
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	60 repr(wr)
22946 cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	61
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	62 def test_basic_callback(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	63 self.check_basic_callback(C)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	64 self.check_basic_callback(create_function)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	65 self.check_basic_callback(create_bound_method)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	66 self.check_basic_callback(create_unbound_method)
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	67
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	68 def test_multiple_callbacks(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	69 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	70 ref1 = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	71 ref2 = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	72 del o
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	73 self.assertTrue(ref1() is None,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	74 "expected reference to be invalidated")
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	75 self.assertTrue(ref2() is None,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	76 "expected reference to be invalidated")
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	77 self.assertTrue(self.cbcalled == 2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	78 "callback not called the right number of times")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	79
17498 f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	80 def test_multiple_selfref_callbacks(self):
24963 73fbcf21b2c0 Standardize behavior: no docstrings in test functions. Also use Guido van Rossum <guido@python.org> parents: 24364 diff changeset	81 # Make sure all references are invalidated before callbacks are called
17498 f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	82 #
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	83 # What's important here is that we're using the first
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	84 # reference in the callback invoked on the second reference
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	85 # (the most recently created ref is cleaned up first). This
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	86 # tests that all references to the object are invalidated
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	87 # before any of the callbacks are invoked, so that we only
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	88 # have one invocation of _weakref.c:cleanup_helper() active
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	89 # for a particular object at a time.
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	90 #
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	91 def callback(object, self=self):
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	92 self.ref()
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	93 c = C()
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	94 self.ref = weakref.ref(c, callback)
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	95 ref1 = weakref.ref(c, callback)
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	96 del c
f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	97
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	98 def test_proxy_ref(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	99 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	100 o.bar = 1
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	101 ref1 = weakref.proxy(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	102 ref2 = weakref.proxy(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	103 del o
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	104
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	105 def check(proxy):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	106 proxy.bar
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	107
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	108 self.assertRaises(weakref.ReferenceError, check, ref1)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	109 self.assertRaises(weakref.ReferenceError, check, ref2)
32530 2451c9572edf SF bug #978308, Spurious errors taking bool of dead pro Neal Norwitz <nnorwitz@gmail.com> parents: 32472 diff changeset	110 self.assertRaises(weakref.ReferenceError, bool, weakref.proxy(C()))
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	111 self.assertTrue(self.cbcalled == 2)
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	112
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	113 def check_basic_ref(self, factory):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	114 o = factory()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	115 ref = weakref.ref(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	116 self.assertTrue(ref() is not None,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	117 "weak reference to live object should be live")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	118 o2 = ref()
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	119 self.assertTrue(o is o2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	120 "<ref>() should return original object if live")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	121
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	122 def check_basic_callback(self, factory):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	123 self.cbcalled = 0
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	124 o = factory()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	125 ref = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	126 del o
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	127 self.assertTrue(self.cbcalled == 1,
17498 f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	128 "callback did not properly set 'cbcalled'")
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	129 self.assertTrue(ref() is None,
17498 f72dcd67cccb Added regression test for SF bug #415660 (failure to invalidate all Fred Drake <fdrake@acm.org> parents: 17385 diff changeset	130 "ref2 should be dead after deleting object reference")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	131
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	132 def test_ref_reuse(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	133 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	134 ref1 = weakref.ref(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	135 # create a proxy to make sure that there's an intervening creation
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	136 # between these two; it should make no difference
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	137 proxy = weakref.proxy(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	138 ref2 = weakref.ref(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	139 self.assertTrue(ref1 is ref2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	140 "reference object w/out callback should be re-used")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	141
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	142 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	143 proxy = weakref.proxy(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	144 ref1 = weakref.ref(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	145 ref2 = weakref.ref(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	146 self.assertTrue(ref1 is ref2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	147 "reference object w/out callback should be re-used")
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	148 self.assertTrue(weakref.getweakrefcount(o) == 2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	149 "wrong weak ref count for object")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	150 del proxy
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	151 self.assertTrue(weakref.getweakrefcount(o) == 1,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	152 "wrong weak ref count for object after deleting proxy")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	153
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	154 def test_proxy_reuse(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	155 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	156 proxy1 = weakref.proxy(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	157 ref = weakref.ref(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	158 proxy2 = weakref.proxy(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	159 self.assertTrue(proxy1 is proxy2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	160 "proxy object w/out callback should have been re-used")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	161
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	162 def test_basic_proxy(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	163 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	164 self.check_proxy(o, weakref.proxy(o))
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	165
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	166 L = UserList.UserList()
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	167 p = weakref.proxy(L)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	168 self.assertFalse(p, "proxy for empty UserList should be false")
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	169 p.append(12)
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	170 self.assertEqual(len(L), 1)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	171 self.assertTrue(p, "proxy for non-empty UserList should be true")
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	172 with test_support.check_py3k_warnings():
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	173 p[:] = [2, 3]
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	174 self.assertEqual(len(L), 2)
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	175 self.assertEqual(len(p), 2)
58460 17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	176 self.assertIn(3, p, "proxy didn't support __contains__() properly")
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	177 p[1] = 5
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	178 self.assertEqual(L[1], 5)
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	179 self.assertEqual(p[1], 5)
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	180 L2 = UserList.UserList(L)
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	181 p2 = weakref.proxy(L2)
2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	182 self.assertEqual(p, p2)
31515 71a294bd7950 Replace backticks with repr() or "%r" Walter Dörwald <walter@livinglogic.de> parents: 31454 diff changeset	183 ## self.assertEqual(repr(L2), repr(p2))
22946 cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	184 L3 = UserList.UserList(range(10))
cc50a091f573 Improve coverage of Objects/weakrefobject.c. Fred Drake <fdrake@acm.org> parents: 21484 diff changeset	185 p3 = weakref.proxy(L3)
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	186 with test_support.check_py3k_warnings():
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	187 self.assertEqual(L3[:], p3[:])
51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	188 self.assertEqual(L3[5:], p3[5:])
51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	189 self.assertEqual(L3[:5], p3[:5])
51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	190 self.assertEqual(L3[2:5], p3[2:5])
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	191
57349 d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	192 def test_proxy_unicode(self):
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	193 # See bug 5037
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	194 class C(object):
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	195 def __str__(self):
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	196 return "string"
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	197 def __unicode__(self):
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	198 return u"unicode"
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	199 instance = C()
58460 17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	200 self.assertIn("__unicode__", dir(weakref.proxy(instance)))
57349 d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	201 self.assertEqual(unicode(weakref.proxy(instance)), u"unicode")
d5779e159ddb Merged revisions 76395 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	202
47196 12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	203 def test_proxy_index(self):
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	204 class C:
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	205 def __index__(self):
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	206 return 10
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	207 o = C()
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	208 p = weakref.proxy(o)
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	209 self.assertEqual(operator.index(p), 10)
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	210
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	211 def test_proxy_div(self):
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	212 class C:
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	213 def __floordiv__(self, other):
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	214 return 42
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	215 def __ifloordiv__(self, other):
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	216 return 21
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	217 o = C()
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	218 p = weakref.proxy(o)
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	219 self.assertEqual(p // 5, 42)
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	220 p //= 5
12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	221 self.assertEqual(p, 21)
21484 2d376d926da8 Add some additional tests that check more proxy behaviors. Fred Drake <fdrake@acm.org> parents: 21340 diff changeset	222
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	223 # The PyWeakref_* C API is documented as allowing either NULL or
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	224 # None as the value for the callback, where either means "no
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	225 # callback". The "no callback" ref and proxy objects are supposed
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	226 # to be shared so long as they exist by all callers so long as
40449 810081812996 Fix typo. Walter Dörwald <walter@livinglogic.de> parents: 38464 diff changeset	227 # they are active. In Python 2.3.3 and earlier, this guarantee
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	228 # was not honored, and was broken in different ways for
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	229 # PyWeakref_NewRef() and PyWeakref_NewProxy(). (Two tests.)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	230
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	231 def test_shared_ref_without_callback(self):
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	232 self.check_shared_without_callback(weakref.ref)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	233
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	234 def test_shared_proxy_without_callback(self):
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	235 self.check_shared_without_callback(weakref.proxy)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	236
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	237 def check_shared_without_callback(self, makeref):
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	238 o = Object(1)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	239 p1 = makeref(o, None)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	240 p2 = makeref(o, None)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	241 self.assertTrue(p1 is p2, "both callbacks were None in the C API")
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	242 del p1, p2
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	243 p1 = makeref(o)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	244 p2 = makeref(o, None)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	245 self.assertTrue(p1 is p2, "callbacks were NULL, None in the C API")
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	246 del p1, p2
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	247 p1 = makeref(o)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	248 p2 = makeref(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	249 self.assertTrue(p1 is p2, "both callbacks were NULL in the C API")
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	250 del p1, p2
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	251 p1 = makeref(o, None)
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	252 p2 = makeref(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	253 self.assertTrue(p1 is p2, "callbacks were None, NULL in the C API")
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	254
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	255 def test_callable_proxy(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	256 o = Callable()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	257 ref1 = weakref.proxy(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	258
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	259 self.check_proxy(o, ref1)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	260
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	261 self.assertTrue(type(ref1) is weakref.CallableProxyType,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	262 "proxy is not of callable type")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	263 ref1('twinkies!')
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	264 self.assertTrue(o.bar == 'twinkies!',
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	265 "call through proxy not passed through to original")
20533 4f7befec35b0 Add a test for calling a weakref proxy with a dictionary of keyword args. Fred Drake <fdrake@acm.org> parents: 20522 diff changeset	266 ref1(x='Splat.')
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	267 self.assertTrue(o.bar == 'Splat.',
20533 4f7befec35b0 Add a test for calling a weakref proxy with a dictionary of keyword args. Fred Drake <fdrake@acm.org> parents: 20522 diff changeset	268 "call through proxy not passed through to original")
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	269
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	270 # expect due to too few args
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	271 self.assertRaises(TypeError, ref1)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	272
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	273 # expect due to too many args
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	274 self.assertRaises(TypeError, ref1, 1, 2, 3)
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	275
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	276 def check_proxy(self, o, proxy):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	277 o.foo = 1
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	278 self.assertTrue(proxy.foo == 1,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	279 "proxy does not reflect attribute addition")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	280 o.foo = 2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	281 self.assertTrue(proxy.foo == 2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	282 "proxy does not reflect attribute modification")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	283 del o.foo
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	284 self.assertTrue(not hasattr(proxy, 'foo'),
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	285 "proxy does not reflect attribute removal")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	286
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	287 proxy.foo = 1
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	288 self.assertTrue(o.foo == 1,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	289 "object does not reflect attribute addition via proxy")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	290 proxy.foo = 2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	291 self.assertTrue(
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	292 o.foo == 2,
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	293 "object does not reflect attribute modification via proxy")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	294 del proxy.foo
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	295 self.assertTrue(not hasattr(o, 'foo'),
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	296 "object does not reflect attribute removal via proxy")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	297
29697 1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	298 def test_proxy_deletion(self):
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	299 # Test clearing of SF bug #762891
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	300 class Foo:
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	301 result = None
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	302 def __delitem__(self, accessor):
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	303 self.result = accessor
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	304 g = Foo()
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	305 f = weakref.proxy(g)
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	306 del f[0]
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	307 self.assertEqual(f.result, 0)
1d763862d1a1 Fix SF 762891: "del p[key]" on proxy object raises SystemError() Raymond Hettinger <python@rcn.com> parents: 29258 diff changeset	308
34847 51ba8ce8d92a SF bug #1770766: weakref proxy has incorrect __nonzero__ behavior. Raymond Hettinger <python@rcn.com> parents: 32530 diff changeset	309 def test_proxy_bool(self):
51ba8ce8d92a SF bug #1770766: weakref proxy has incorrect __nonzero__ behavior. Raymond Hettinger <python@rcn.com> parents: 32530 diff changeset	310 # Test clearing of SF bug #1170766
51ba8ce8d92a SF bug #1770766: weakref proxy has incorrect __nonzero__ behavior. Raymond Hettinger <python@rcn.com> parents: 32530 diff changeset	311 class List(list): pass
51ba8ce8d92a SF bug #1770766: weakref proxy has incorrect __nonzero__ behavior. Raymond Hettinger <python@rcn.com> parents: 32530 diff changeset	312 lyst = List()
51ba8ce8d92a SF bug #1770766: weakref proxy has incorrect __nonzero__ behavior. Raymond Hettinger <python@rcn.com> parents: 32530 diff changeset	313 self.assertEqual(bool(weakref.proxy(lyst)), bool(lyst))
51ba8ce8d92a SF bug #1770766: weakref proxy has incorrect __nonzero__ behavior. Raymond Hettinger <python@rcn.com> parents: 32530 diff changeset	314
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	315 def test_getweakrefcount(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	316 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	317 ref1 = weakref.ref(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	318 ref2 = weakref.ref(o, self.callback)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	319 self.assertTrue(weakref.getweakrefcount(o) == 2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	320 "got wrong number of weak reference objects")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	321
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	322 proxy1 = weakref.proxy(o)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	323 proxy2 = weakref.proxy(o, self.callback)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	324 self.assertTrue(weakref.getweakrefcount(o) == 4,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	325 "got wrong number of weak reference objects")
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	326
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	327 del ref1, ref2, proxy1, proxy2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	328 self.assertTrue(weakref.getweakrefcount(o) == 0,
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	329 "weak reference objects not unlinked from"
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	330 " referent when discarded.")
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	331
31168 48702f19ccfb Add tests to test_weakref.py to bring code coverage in _weakref.c up to 100%. Walter Dörwald <walter@livinglogic.de> parents: 30988 diff changeset	332 # assumes ints do not support weakrefs
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	333 self.assertTrue(weakref.getweakrefcount(1) == 0,
31168 48702f19ccfb Add tests to test_weakref.py to bring code coverage in _weakref.c up to 100%. Walter Dörwald <walter@livinglogic.de> parents: 30988 diff changeset	334 "got wrong number of weak reference objects for int")
48702f19ccfb Add tests to test_weakref.py to bring code coverage in _weakref.c up to 100%. Walter Dörwald <walter@livinglogic.de> parents: 30988 diff changeset	335
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	336 def test_getweakrefs(self):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	337 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	338 ref1 = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	339 ref2 = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	340 del ref1
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	341 self.assertTrue(weakref.getweakrefs(o) == [ref2],
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	342 "list of refs does not match")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	343
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	344 o = C()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	345 ref1 = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	346 ref2 = weakref.ref(o, self.callback)
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	347 del ref2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	348 self.assertTrue(weakref.getweakrefs(o) == [ref1],
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	349 "list of refs does not match")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	350
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	351 del ref1
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	352 self.assertTrue(weakref.getweakrefs(o) == [],
31448 dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	353 "list of refs not cleared")
dfc1819b4eb4 - add tests that exercise fixes for the PyWeakref_NewRef() and Fred Drake <fdrake@acm.org> parents: 31168 diff changeset	354
31168 48702f19ccfb Add tests to test_weakref.py to bring code coverage in _weakref.c up to 100%. Walter Dörwald <walter@livinglogic.de> parents: 30988 diff changeset	355 # assumes ints do not support weakrefs
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	356 self.assertTrue(weakref.getweakrefs(1) == [],
31168 48702f19ccfb Add tests to test_weakref.py to bring code coverage in _weakref.c up to 100%. Walter Dörwald <walter@livinglogic.de> parents: 30988 diff changeset	357 "list of refs does not match for int")
48702f19ccfb Add tests to test_weakref.py to bring code coverage in _weakref.c up to 100%. Walter Dörwald <walter@livinglogic.de> parents: 30988 diff changeset	358
20522 3d13417a63e0 Make sure we do not core dump when using proxies with the binary slot Fred Drake <fdrake@acm.org> parents: 20013 diff changeset	359 def test_newstyle_number_ops(self):
3d13417a63e0 Make sure we do not core dump when using proxies with the binary slot Fred Drake <fdrake@acm.org> parents: 20013 diff changeset	360 class F(float):
3d13417a63e0 Make sure we do not core dump when using proxies with the binary slot Fred Drake <fdrake@acm.org> parents: 20013 diff changeset	361 pass
3d13417a63e0 Make sure we do not core dump when using proxies with the binary slot Fred Drake <fdrake@acm.org> parents: 20013 diff changeset	362 f = F(2.0)
3d13417a63e0 Make sure we do not core dump when using proxies with the binary slot Fred Drake <fdrake@acm.org> parents: 20013 diff changeset	363 p = weakref.proxy(f)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	364 self.assertTrue(p + 1.0 == 3.0)
6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	365 self.assertTrue(1.0 + p == 3.0) # this used to SEGV
20522 3d13417a63e0 Make sure we do not core dump when using proxies with the binary slot Fred Drake <fdrake@acm.org> parents: 20013 diff changeset	366
21340 3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	367 def test_callbacks_protected(self):
24963 73fbcf21b2c0 Standardize behavior: no docstrings in test functions. Also use Guido van Rossum <guido@python.org> parents: 24364 diff changeset	368 # Callbacks protected from already-set exceptions?
21340 3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	369 # Regression test for SF bug #478534.
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	370 class BogusError(Exception):
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	371 pass
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	372 data = {}
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	373 def remove(k):
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	374 del data[k]
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	375 def encapsulate():
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	376 f = lambda : ()
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	377 data[weakref.ref(f, remove)] = None
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	378 raise BogusError
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	379 try:
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	380 encapsulate()
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	381 except BogusError:
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	382 pass
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	383 else:
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	384 self.fail("exception not properly restored")
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	385 try:
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	386 encapsulate()
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	387 except BogusError:
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	388 pass
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	389 else:
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	390 self.fail("exception not properly restored")
3d68e3110e1f Regression test for SF bug #478534 -- exceptions could "leak" into a weakref Fred Drake <fdrake@acm.org> parents: 20903 diff changeset	391
30908 cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	392 def test_sf_bug_840829(self):
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	393 # "weakref callbacks and gc corrupt memory"
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	394 # subtype_dealloc erroneously exposed a new-style instance
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	395 # already in the process of getting deallocated to gc,
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	396 # causing double-deallocation if the instance had a weakref
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	397 # callback that triggered gc.
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	398 # If the bug exists, there probably won't be an obvious symptom
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	399 # in a release build. In a debug build, a segfault will occur
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	400 # when the second attempt to remove the instance from the "list
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	401 # of all objects" occurs.
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	402
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	403 import gc
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	404
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	405 class C(object):
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	406 pass
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	407
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	408 c = C()
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	409 wr = weakref.ref(c, lambda ignore: gc.collect())
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	410 del c
cd7624b025a0 Backport of fix for SF bug 840829, memory corruption in some cases of Tim Peters <tim.peters@gmail.com> parents: 29862 diff changeset	411
30916 81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	412 # There endeth the first part. It gets worse.
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	413 del wr
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	414
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	415 c1 = C()
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	416 c1.i = C()
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	417 wr = weakref.ref(c1.i, lambda ignore: gc.collect())
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	418
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	419 c2 = C()
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	420 c2.c1 = c1
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	421 del c1 # still alive because c2 points to it
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	422
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	423 # Now when subtype_dealloc gets called on c2, it's not enough just
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	424 # that c2 is immune from gc while the weakref callbacks associated
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	425 # with c2 execute (there are none in this 2nd half of the test, btw).
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	426 # subtype_dealloc goes on to call the base classes' deallocs too,
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	427 # so any gc triggered by weakref callbacks associated with anything
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	428 # torn down by a base class dealloc can also trigger double
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	429 # deallocation of c2.
81733c7a95c8 subtype_dealloc(): A more complete fix for critical bug 840829 + Tim Peters <tim.peters@gmail.com> parents: 30908 diff changeset	430 del c2
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	431
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	432 def test_callback_in_cycle_1(self):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	433 import gc
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	434
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	435 class J(object):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	436 pass
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	437
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	438 class II(object):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	439 def acallback(self, ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	440 self.J
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	441
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	442 I = II()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	443 I.J = J
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	444 I.wr = weakref.ref(J, I.acallback)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	445
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	446 # Now J and II are each in a self-cycle (as all new-style class
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	447 # objects are, since their __mro__ points back to them). I holds
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	448 # both a weak reference (I.wr) and a strong reference (I.J) to class
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	449 # J. I is also in a cycle (I.wr points to a weakref that references
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	450 # I.acallback). When we del these three, they all become trash, but
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	451 # the cycles prevent any of them from getting cleaned up immediately.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	452 # Instead they have to wait for cyclic gc to deduce that they're
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	453 # trash.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	454 #
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	455 # gc used to call tp_clear on all of them, and the order in which
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	456 # it does that is pretty accidental. The exact order in which we
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	457 # built up these things manages to provoke gc into running tp_clear
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	458 # in just the right order (I last). Calling tp_clear on II leaves
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	459 # behind an insane class object (its __mro__ becomes NULL). Calling
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	460 # tp_clear on J breaks its self-cycle, but J doesn't get deleted
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	461 # just then because of the strong reference from I.J. Calling
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	462 # tp_clear on I starts to clear I's __dict__, and just happens to
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	463 # clear I.J first -- I.wr is still intact. That removes the last
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	464 # reference to J, which triggers the weakref callback. The callback
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	465 # tries to do "self.J", and instances of new-style classes look up
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	466 # attributes ("J") in the class dict first. The class (II) wants to
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	467 # search II.__mro__, but that's NULL. The result was a segfault in
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	468 # a release build, and an assert failure in a debug build.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	469 del I, J, II
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	470 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	471
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	472 def test_callback_in_cycle_2(self):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	473 import gc
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	474
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	475 # This is just like test_callback_in_cycle_1, except that II is an
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	476 # old-style class. The symptom is different then: an instance of an
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	477 # old-style class looks in its own __dict__ first. 'J' happens to
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	478 # get cleared from I.__dict__ before 'wr', and 'J' was never in II's
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	479 # __dict__, so the attribute isn't found. The difference is that
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	480 # the old-style II doesn't have a NULL __mro__ (it doesn't have any
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	481 # __mro__), so no segfault occurs. Instead it got:
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	482 # test_callback_in_cycle_2 (__main__.ReferencesTestCase) ...
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	483 # Exception exceptions.AttributeError:
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	484 # "II instance has no attribute 'J'" in <bound method II.acallback
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	485 # of <?.II instance at 0x00B9B4B8>> ignored
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	486
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	487 class J(object):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	488 pass
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	489
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	490 class II:
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	491 def acallback(self, ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	492 self.J
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	493
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	494 I = II()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	495 I.J = J
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	496 I.wr = weakref.ref(J, I.acallback)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	497
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	498 del I, J, II
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	499 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	500
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	501 def test_callback_in_cycle_3(self):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	502 import gc
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	503
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	504 # This one broke the first patch that fixed the last two. In this
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	505 # case, the objects reachable from the callback aren't also reachable
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	506 # from the object (c1) triggering the callback: you can get to
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	507 # c1 from c2, but not vice-versa. The result was that c2's __dict__
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	508 # got tp_clear'ed by the time the c2.cb callback got invoked.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	509
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	510 class C:
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	511 def cb(self, ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	512 self.me
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	513 self.c1
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	514 self.wr
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	515
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	516 c1, c2 = C(), C()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	517
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	518 c2.me = c2
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	519 c2.c1 = c1
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	520 c2.wr = weakref.ref(c1, c2.cb)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	521
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	522 del c1, c2
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	523 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	524
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	525 def test_callback_in_cycle_4(self):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	526 import gc
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	527
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	528 # Like test_callback_in_cycle_3, except c2 and c1 have different
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	529 # classes. c2's class (C) isn't reachable from c1 then, so protecting
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	530 # objects reachable from the dying object (c1) isn't enough to stop
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	531 # c2's class (C) from getting tp_clear'ed before c2.cb is invoked.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	532 # The result was a segfault (C.__mro__ was NULL when the callback
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	533 # tried to look up self.me).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	534
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	535 class C(object):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	536 def cb(self, ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	537 self.me
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	538 self.c1
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	539 self.wr
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	540
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	541 class D:
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	542 pass
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	543
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	544 c1, c2 = D(), C()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	545
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	546 c2.me = c2
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	547 c2.c1 = c1
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	548 c2.wr = weakref.ref(c1, c2.cb)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	549
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	550 del c1, c2, C, D
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	551 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	552
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	553 def test_callback_in_cycle_resurrection(self):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	554 import gc
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	555
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	556 # Do something nasty in a weakref callback: resurrect objects
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	557 # from dead cycles. For this to be attempted, the weakref and
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	558 # its callback must also be part of the cyclic trash (else the
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	559 # objects reachable via the callback couldn't be in cyclic trash
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	560 # to begin with -- the callback would act like an external root).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	561 # But gc clears trash weakrefs with callbacks early now, which
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	562 # disables the callbacks, so the callbacks shouldn't get called
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	563 # at all (and so nothing actually gets resurrected).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	564
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	565 alist = []
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	566 class C(object):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	567 def __init__(self, value):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	568 self.attribute = value
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	569
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	570 def acallback(self, ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	571 alist.append(self.c)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	572
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	573 c1, c2 = C(1), C(2)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	574 c1.c = c2
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	575 c2.c = c1
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	576 c1.wr = weakref.ref(c2, c1.acallback)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	577 c2.wr = weakref.ref(c1, c2.acallback)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	578
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	579 def C_went_away(ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	580 alist.append("C went away")
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	581 wr = weakref.ref(C, C_went_away)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	582
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	583 del c1, c2, C # make them all trash
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	584 self.assertEqual(alist, []) # del isn't enough to reclaim anything
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	585
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	586 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	587 # c1.wr and c2.wr were part of the cyclic trash, so should have
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	588 # been cleared without their callbacks executing. OTOH, the weakref
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	589 # to C is bound to a function local (wr), and wasn't trash, so that
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	590 # callback should have been invoked when C went away.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	591 self.assertEqual(alist, ["C went away"])
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	592 # The remaining weakref should be dead now (its callback ran).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	593 self.assertEqual(wr(), None)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	594
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	595 del alist[:]
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	596 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	597 self.assertEqual(alist, [])
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	598
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	599 def test_callbacks_on_callback(self):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	600 import gc
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	601
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	602 # Set up weakref callbacks on weakref callbacks.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	603 alist = []
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	604 def safe_callback(ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	605 alist.append("safe_callback called")
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	606
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	607 class C(object):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	608 def cb(self, ignore):
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	609 alist.append("cb called")
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	610
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	611 c, d = C(), C()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	612 c.other = d
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	613 d.other = c
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	614 callback = c.cb
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	615 c.wr = weakref.ref(d, callback) # this won't trigger
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	616 d.wr = weakref.ref(callback, d.cb) # ditto
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	617 external_wr = weakref.ref(callback, safe_callback) # but this will
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	618 self.assertTrue(external_wr() is callback)
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	619
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	620 # The weakrefs attached to c and d should get cleared, so that
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	621 # C.cb is never called. But external_wr isn't part of the cyclic
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	622 # trash, and no cyclic trash is reachable from it, so safe_callback
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	623 # should get invoked when the bound method object callback (c.cb)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	624 # -- which is itself a callback, and also part of the cyclic trash --
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	625 # gets reclaimed at the end of gc.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	626
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	627 del callback, c, d, C
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	628 self.assertEqual(alist, []) # del isn't enough to clean up cycles
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	629 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	630 self.assertEqual(alist, ["safe_callback called"])
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	631 self.assertEqual(external_wr(), None)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	632
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	633 del alist[:]
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	634 gc.collect()
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	635 self.assertEqual(alist, [])
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30929 diff changeset	636
31454 d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	637 def test_gc_during_ref_creation(self):
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	638 self.check_gc_during_creation(weakref.ref)
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	639
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	640 def test_gc_during_proxy_creation(self):
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	641 self.check_gc_during_creation(weakref.proxy)
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	642
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	643 def check_gc_during_creation(self, makeref):
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	644 thresholds = gc.get_threshold()
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	645 gc.set_threshold(1, 1, 1)
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	646 gc.collect()
31522 239443933324 further testing indicates that the simplified version of the test Fred Drake <fdrake@acm.org> parents: 31517 diff changeset	647 class A:
239443933324 further testing indicates that the simplified version of the test Fred Drake <fdrake@acm.org> parents: 31517 diff changeset	648 pass
31454 d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	649
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	650 def callback(*args):
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	651 pass
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	652
31522 239443933324 further testing indicates that the simplified version of the test Fred Drake <fdrake@acm.org> parents: 31517 diff changeset	653 referenced = A()
31454 d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	654
31522 239443933324 further testing indicates that the simplified version of the test Fred Drake <fdrake@acm.org> parents: 31517 diff changeset	655 a = A()
31454 d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	656 a.a = a
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	657 a.wr = makeref(referenced)
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	658
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	659 try:
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	660 # now make sure the object and the ref get labeled as
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	661 # cyclic trash:
31522 239443933324 further testing indicates that the simplified version of the test Fred Drake <fdrake@acm.org> parents: 31517 diff changeset	662 a = A()
239443933324 further testing indicates that the simplified version of the test Fred Drake <fdrake@acm.org> parents: 31517 diff changeset	663 weakref.ref(referenced, callback)
31454 d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	664
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	665 finally:
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	666 gc.set_threshold(*thresholds)
d4165d12f73c Allocating a new weakref object can cause existing weakref objects for Fred Drake <fdrake@acm.org> parents: 31448 diff changeset	667
40705 293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	668 def test_ref_created_during_del(self):
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	669 # Bug #1377858
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	670 # A weakref created in an object's __del__() would crash the
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	671 # interpreter when the weakref was cleaned up since it would refer to
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	672 # non-existent memory. This test should not segfault the interpreter.
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	673 class Target(object):
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	674 def __del__(self):
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	675 global ref_from_del
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	676 ref_from_del = weakref.ref(self)
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	677
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	678 w = Target()
293311e63a73 If you created a weakref in an object's __del__ method to itself it would Brett Cannon <bcannon@gmail.com> parents: 38464 diff changeset	679
49120 73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	680 def test_init(self):
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	681 # Issue 3634
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	682 # <weakref to class>.__init__() doesn't check errors correctly
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	683 r = weakref.ref(Exception)
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	684 self.assertRaises(TypeError, r.__init__, 0, 0, 0, 0, 0)
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	685 # No exception should be raised here
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	686 gc.collect()
73cc7b6355b8 Fix #3634 invalid return value from _weakref.ref(Exception).__init__ Benjamin Peterson <benjamin@python.org> parents: 47732 diff changeset	687
60112 7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	688 def test_classes(self):
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	689 # Check that both old-style classes and new-style classes
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	690 # are weakrefable.
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	691 class A(object):
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	692 pass
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	693 class B:
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	694 pass
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	695 l = []
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	696 weakref.ref(int)
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	697 a = weakref.ref(A, l.append)
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	698 A = None
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	699 gc.collect()
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	700 self.assertEqual(a(), None)
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	701 self.assertEqual(l, [a])
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	702 b = weakref.ref(B, l.append)
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	703 B = None
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	704 gc.collect()
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	705 self.assertEqual(b(), None)
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	706 self.assertEqual(l, [a, b])
7b8ba019cd15 Issue #8268: Old-style classes (not just instances) now support weak Antoine Pitrou <solipsis@pitrou.net> parents: 59783 diff changeset	707
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	708
47733 4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	709 class SubclassableWeakrefTestCase(TestBase):
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	710
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	711 def test_subclass_refs(self):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	712 class MyRef(weakref.ref):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	713 def __init__(self, ob, callback=None, value=42):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	714 self.value = value
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	715 super(MyRef, self).__init__(ob, callback)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	716 def __call__(self):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	717 self.called = True
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	718 return super(MyRef, self).__call__()
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	719 o = Object("foo")
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	720 mr = MyRef(o, value=24)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	721 self.assertTrue(mr() is o)
6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	722 self.assertTrue(mr.called)
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	723 self.assertEqual(mr.value, 24)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	724 del o
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	725 self.assertTrue(mr() is None)
6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	726 self.assertTrue(mr.called)
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	727
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	728 def test_subclass_refs_dont_replace_standard_refs(self):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	729 class MyRef(weakref.ref):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	730 pass
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	731 o = Object(42)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	732 r1 = MyRef(o)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	733 r2 = weakref.ref(o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	734 self.assertTrue(r1 is not r2)
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	735 self.assertEqual(weakref.getweakrefs(o), [r2, r1])
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	736 self.assertEqual(weakref.getweakrefcount(o), 2)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	737 r3 = MyRef(o)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	738 self.assertEqual(weakref.getweakrefcount(o), 3)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	739 refs = weakref.getweakrefs(o)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	740 self.assertEqual(len(refs), 3)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	741 self.assertTrue(r2 is refs[0])
58460 17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	742 self.assertIn(r1, refs[1:])
17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	743 self.assertIn(r3, refs[1:])
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	744
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	745 def test_subclass_refs_dont_conflate_callbacks(self):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	746 class MyRef(weakref.ref):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	747 pass
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	748 o = Object(42)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	749 r1 = MyRef(o, id)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	750 r2 = MyRef(o, str)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	751 self.assertTrue(r1 is not r2)
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	752 refs = weakref.getweakrefs(o)
58460 17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	753 self.assertIn(r1, refs)
17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	754 self.assertIn(r2, refs)
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	755
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	756 def test_subclass_refs_with_slots(self):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	757 class MyRef(weakref.ref):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	758 __slots__ = "slot1", "slot2"
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	759 def __new__(type, ob, callback, slot1, slot2):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	760 return weakref.ref.__new__(type, ob, callback)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	761 def __init__(self, ob, callback, slot1, slot2):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	762 self.slot1 = slot1
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	763 self.slot2 = slot2
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	764 def meth(self):
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	765 return self.slot1 + self.slot2
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	766 o = Object(42)
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	767 r = MyRef(o, None, "abc", "def")
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	768 self.assertEqual(r.slot1, "abc")
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	769 self.assertEqual(r.slot2, "def")
4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	770 self.assertEqual(r.meth(), "abcdef")
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	771 self.assertFalse(hasattr(r, "__dict__"))
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	772
47733 4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	773 def test_subclass_refs_with_cycle(self):
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	774 # Bug #3110
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	775 # An instance of a weakref subclass can have attributes.
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	776 # If such a weakref holds the only strong reference to the object,
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	777 # deleting the weakref will delete the object. In this case,
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	778 # the callback must not be called, because the ref object is
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	779 # being deleted.
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	780 class MyRef(weakref.ref):
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	781 pass
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	782
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	783 # Use a local callback, for "regrtest -R::"
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	784 # to detect refcounting problems
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	785 def callback(w):
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	786 self.cbcalled += 1
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	787
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	788 o = C()
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	789 r1 = MyRef(o, callback)
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	790 r1.o = o
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	791 del o
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	792
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	793 del r1 # Used to crash here
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	794
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	795 self.assertEqual(self.cbcalled, 0)
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	796
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	797 # Same test, with two weakrefs to the same object
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	798 # (since code paths are different)
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	799 o = C()
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	800 r1 = MyRef(o, callback)
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	801 r2 = MyRef(o, callback)
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	802 r1.r = r2
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	803 r2.o = o
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	804 del o
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	805 del r2
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	806
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	807 del r1 # Used to crash here
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	808
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	809 self.assertEqual(self.cbcalled, 0)
4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	810
32472 4383db77b19a Make weak references subclassable: Fred Drake <fdrake@acm.org> parents: 32204 diff changeset	811
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	812 class Object:
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	813 def __init__(self, arg):
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	814 self.arg = arg
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	815 def __repr__(self):
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	816 return "<Object %r>" % self.arg
1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	817
75358 b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	818 class RefCycle:
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	819 def __init__(self):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	820 self.cycle = self
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	821
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	822
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	823 class MappingTestCase(TestBase):
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	824
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	825 COUNT = 10
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	826
75358 b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	827 def check_len_cycles(self, dict_type, cons):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	828 N = 20
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	829 items = [RefCycle() for i in range(N)]
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	830 dct = dict_type(cons(o) for o in items)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	831 # Keep an iterator alive
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	832 it = dct.iteritems()
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	833 try:
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	834 next(it)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	835 except StopIteration:
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	836 pass
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	837 del items
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	838 gc.collect()
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	839 n1 = len(dct)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	840 del it
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	841 gc.collect()
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	842 n2 = len(dct)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	843 # one item may be kept alive inside the iterator
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	844 self.assertIn(n1, (0, 1))
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	845 self.assertEqual(n2, 0)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	846
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	847 def test_weak_keyed_len_cycles(self):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	848 self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	849
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	850 def test_weak_valued_len_cycles(self):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	851 self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	852
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	853 def check_len_race(self, dict_type, cons):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	854 # Extended sanity checks for len() in the face of cyclic collection
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	855 self.addCleanup(gc.set_threshold, *gc.get_threshold())
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	856 for th in range(1, 100):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	857 N = 20
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	858 gc.collect(0)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	859 gc.set_threshold(th, th, th)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	860 items = [RefCycle() for i in range(N)]
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	861 dct = dict_type(cons(o) for o in items)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	862 del items
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	863 # All items will be collected at next garbage collection pass
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	864 it = dct.iteritems()
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	865 try:
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	866 next(it)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	867 except StopIteration:
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	868 pass
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	869 n1 = len(dct)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	870 del it
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	871 n2 = len(dct)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	872 self.assertGreaterEqual(n1, 0)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	873 self.assertLessEqual(n1, N)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	874 self.assertGreaterEqual(n2, 0)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	875 self.assertLessEqual(n2, n1)
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	876
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	877 def test_weak_keyed_len_race(self):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	878 self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	879
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	880 def test_weak_valued_len_race(self):
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	881 self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
b6acfbe2bdbe Issue #14159: Fix the len() of weak sets to return a better approximation when some objects are dead or dying. Antoine Pitrou <solipsis@pitrou.net> parents: 68256 diff changeset	882
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	883 def test_weak_values(self):
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	884 #
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	885 # This exercises d.copy(), d.items(), d[], del d[], len(d).
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	886 #
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	887 dict, objects = self.make_weak_valued_dict()
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	888 for o in objects:
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	889 self.assertTrue(weakref.getweakrefcount(o) == 1,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	890 "wrong number of weak references to %r!" % o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	891 self.assertTrue(o is dict[o.arg],
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	892 "wrong object returned by weak dict!")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	893 items1 = dict.items()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	894 items2 = dict.copy().items()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	895 items1.sort()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	896 items2.sort()
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	897 self.assertTrue(items1 == items2,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	898 "cloning of weak-valued dictionary did not work!")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	899 del items1, items2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	900 self.assertTrue(len(dict) == self.COUNT)
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	901 del objects[0]
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	902 self.assertTrue(len(dict) == (self.COUNT - 1),
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	903 "deleting object did not cause dictionary update")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	904 del objects, o
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	905 self.assertTrue(len(dict) == 0,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	906 "deleting the values did not clear the dictionary")
18952 e90a658a58d4 Make sure that WeakValueDictionary[] raises KeyError instead of TypeError Fred Drake <fdrake@acm.org> parents: 17767 diff changeset	907 # regression on SF bug #447152:
e90a658a58d4 Make sure that WeakValueDictionary[] raises KeyError instead of TypeError Fred Drake <fdrake@acm.org> parents: 17767 diff changeset	908 dict = weakref.WeakValueDictionary()
e90a658a58d4 Make sure that WeakValueDictionary[] raises KeyError instead of TypeError Fred Drake <fdrake@acm.org> parents: 17767 diff changeset	909 self.assertRaises(KeyError, dict.__getitem__, 1)
e90a658a58d4 Make sure that WeakValueDictionary[] raises KeyError instead of TypeError Fred Drake <fdrake@acm.org> parents: 17767 diff changeset	910 dict[2] = C()
e90a658a58d4 Make sure that WeakValueDictionary[] raises KeyError instead of TypeError Fred Drake <fdrake@acm.org> parents: 17767 diff changeset	911 self.assertRaises(KeyError, dict.__getitem__, 2)
16794 29aa832b8787 Patch #403985: Add support for weak-keyed dictionaries Martin v. Löwis <martin@v.loewis.de> parents: 16385 diff changeset	912
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	913 def test_weak_keys(self):
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	914 #
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	915 # This exercises d.copy(), d.items(), d[] = v, d[], del d[],
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	916 # len(d), in d.
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	917 #
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	918 dict, objects = self.make_weak_keyed_dict()
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	919 for o in objects:
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	920 self.assertTrue(weakref.getweakrefcount(o) == 1,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	921 "wrong number of weak references to %r!" % o)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	922 self.assertTrue(o.arg is dict[o],
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	923 "wrong object returned by weak dict!")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	924 items1 = dict.items()
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	925 items2 = dict.copy().items()
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	926 self.assertTrue(set(items1) == set(items2),
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	927 "cloning of weak-keyed dictionary did not work!")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	928 del items1, items2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	929 self.assertTrue(len(dict) == self.COUNT)
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	930 del objects[0]
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	931 self.assertTrue(len(dict) == (self.COUNT - 1),
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	932 "deleting object did not cause dictionary update")
10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	933 del objects, o
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	934 self.assertTrue(len(dict) == 0,
17172 10902ecabca9 Convert the weakref test suite to PyUNIT, and add tests that exercise weak Fred Drake <fdrake@acm.org> parents: 16885 diff changeset	935 "deleting the keys did not clear the dictionary")
20903 bfcc2ed9caba Add a regression test for SF bug #478536: If a value cannot be weakly Fred Drake <fdrake@acm.org> parents: 20533 diff changeset	936 o = Object(42)
bfcc2ed9caba Add a regression test for SF bug #478536: If a value cannot be weakly Fred Drake <fdrake@acm.org> parents: 20533 diff changeset	937 dict[o] = "What is the meaning of the universe?"
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	938 self.assertIn(o, dict)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	939 self.assertNotIn(34, dict)
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	940
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	941 def test_weak_keyed_iters(self):
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	942 dict, objects = self.make_weak_keyed_dict()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	943 self.check_iters(dict)
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	944
38079 728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	945 # Test keyrefs()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	946 refs = dict.keyrefs()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	947 self.assertEqual(len(refs), len(objects))
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	948 objects2 = list(objects)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	949 for wr in refs:
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	950 ob = wr()
58460 17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	951 self.assertIn(ob, dict)
38079 728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	952 self.assertEqual(ob.arg, dict[ob])
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	953 objects2.remove(ob)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	954 self.assertEqual(len(objects2), 0)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	955
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	956 # Test iterkeyrefs()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	957 objects2 = list(objects)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	958 self.assertEqual(len(list(dict.iterkeyrefs())), len(objects))
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	959 for wr in dict.iterkeyrefs():
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	960 ob = wr()
58460 17891566a478 use assert[Not]In where appropriate Ezio Melotti <ezio.melotti@gmail.com> parents: 58198 diff changeset	961 self.assertIn(ob, dict)
38079 728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	962 self.assertEqual(ob.arg, dict[ob])
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	963 objects2.remove(ob)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	964 self.assertEqual(len(objects2), 0)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	965
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	966 def test_weak_valued_iters(self):
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	967 dict, objects = self.make_weak_valued_dict()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	968 self.check_iters(dict)
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	969
38079 728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	970 # Test valuerefs()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	971 refs = dict.valuerefs()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	972 self.assertEqual(len(refs), len(objects))
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	973 objects2 = list(objects)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	974 for wr in refs:
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	975 ob = wr()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	976 self.assertEqual(ob, dict[ob.arg])
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	977 self.assertEqual(ob.arg, dict[ob.arg].arg)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	978 objects2.remove(ob)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	979 self.assertEqual(len(objects2), 0)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	980
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	981 # Test itervaluerefs()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	982 objects2 = list(objects)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	983 self.assertEqual(len(list(dict.itervaluerefs())), len(objects))
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	984 for wr in dict.itervaluerefs():
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	985 ob = wr()
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	986 self.assertEqual(ob, dict[ob.arg])
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	987 self.assertEqual(ob.arg, dict[ob.arg].arg)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	988 objects2.remove(ob)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	989 self.assertEqual(len(objects2), 0)
728c16f16267 SF #1479988: add methods to allow access to weakrefs for the Fred Drake <fdrake@acm.org> parents: 35195 diff changeset	990
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	991 def check_iters(self, dict):
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	992 # item iterator:
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	993 items = dict.items()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	994 for item in dict.iteritems():
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	995 items.remove(item)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	996 self.assertTrue(len(items) == 0, "iteritems() did not touch all items")
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	997
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	998 # key iterator, via __iter__():
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	999 keys = dict.keys()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1000 for k in dict:
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1001 keys.remove(k)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1002 self.assertTrue(len(keys) == 0, "__iter__() did not touch all keys")
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1003
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1004 # key iterator, via iterkeys():
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1005 keys = dict.keys()
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1006 for k in dict.iterkeys():
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1007 keys.remove(k)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1008 self.assertTrue(len(keys) == 0, "iterkeys() did not touch all keys")
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1009
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1010 # value iterator:
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1011 values = dict.values()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1012 for v in dict.itervalues():
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1013 values.remove(v)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1014 self.assertTrue(len(values) == 0,
29862 f339f29b06cb stylistic nits: Fred Drake <fdrake@acm.org> parents: 29697 diff changeset	1015 "itervalues() did not touch all values")
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1016
23764 d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1017 def test_make_weak_keyed_dict_from_dict(self):
d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1018 o = Object(3)
d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1019 dict = weakref.WeakKeyDictionary({o:364})
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1020 self.assertTrue(dict[o] == 364)
23764 d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1021
d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1022 def test_make_weak_keyed_dict_from_weak_keyed_dict(self):
d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1023 o = Object(3)
d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1024 dict = weakref.WeakKeyDictionary({o:364})
d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1025 dict2 = weakref.WeakKeyDictionary(dict)
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1026 self.assertTrue(dict[o] == 364)
23764 d58fb5445118 SF patch 564549 (Erik Andersén). Guido van Rossum <guido@python.org> parents: 22946 diff changeset	1027
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1028 def make_weak_keyed_dict(self):
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1029 dict = weakref.WeakKeyDictionary()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1030 objects = map(Object, range(self.COUNT))
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1031 for o in objects:
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1032 dict[o] = o.arg
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1033 return dict, objects
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1034
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1035 def make_weak_valued_dict(self):
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1036 dict = weakref.WeakValueDictionary()
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1037 objects = map(Object, range(self.COUNT))
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1038 for o in objects:
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1039 dict[o.arg] = o
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1040 return dict, objects
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1041
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1042 def check_popitem(self, klass, key1, value1, key2, value2):
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1043 weakdict = klass()
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1044 weakdict[key1] = value1
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1045 weakdict[key2] = value2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1046 self.assertTrue(len(weakdict) == 2)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1047 k, v = weakdict.popitem()
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1048 self.assertTrue(len(weakdict) == 1)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1049 if k is key1:
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1050 self.assertTrue(v is value1)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1051 else:
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1052 self.assertTrue(v is value2)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1053 k, v = weakdict.popitem()
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1054 self.assertTrue(len(weakdict) == 0)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1055 if k is key1:
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1056 self.assertTrue(v is value1)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1057 else:
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1058 self.assertTrue(v is value2)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1059
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1060 def test_weak_valued_dict_popitem(self):
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1061 self.check_popitem(weakref.WeakValueDictionary,
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1062 "key1", C(), "key2", C())
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1063
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1064 def test_weak_keyed_dict_popitem(self):
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1065 self.check_popitem(weakref.WeakKeyDictionary,
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1066 C(), "value 1", C(), "value 2")
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1067
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1068 def check_setdefault(self, klass, key, value1, value2):
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1069 self.assertTrue(value1 is not value2,
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1070 "invalid test"
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1071 " -- value parameters must be distinct objects")
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1072 weakdict = klass()
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1073 o = weakdict.setdefault(key, value1)
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1074 self.assertIs(o, value1)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1075 self.assertIn(key, weakdict)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1076 self.assertIs(weakdict.get(key), value1)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1077 self.assertIs(weakdict[key], value1)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1078
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1079 o = weakdict.setdefault(key, value2)
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1080 self.assertIs(o, value1)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1081 self.assertIn(key, weakdict)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1082 self.assertIs(weakdict.get(key), value1)
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1083 self.assertIs(weakdict[key], value1)
17767 47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1084
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1085 def test_weak_valued_dict_setdefault(self):
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1086 self.check_setdefault(weakref.WeakValueDictionary,
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1087 "key", C(), C())
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1088
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1089 def test_weak_keyed_dict_setdefault(self):
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1090 self.check_setdefault(weakref.WeakKeyDictionary,
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1091 C(), "value 1", "value 2")
47f4d0568c7c Extend the weakref test suite to cover the complete mapping interface for Fred Drake <fdrake@acm.org> parents: 17651 diff changeset	1092
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1093 def check_update(self, klass, dict):
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1094 #
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	1095 # This exercises d.update(), len(d), d.keys(), in d,
17651 fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1096 # d.get(), d[].
fa8326cc761c Added tests for WeakDictionary iterator support. Fred Drake <fdrake@acm.org>* parents: 17547 diff changeset	1097 #
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1098 weakdict = klass()
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1099 weakdict.update(dict)
63572 51102abdec50 Merged revisions 79165 via svnmerge from Ezio Melotti <ezio.melotti@gmail.com> parents: 57349 diff changeset	1100 self.assertEqual(len(weakdict), len(dict))
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1101 for k in weakdict.keys():
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1102 self.assertIn(k, dict,
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1103 "mysterious new key appeared in weak dict")
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1104 v = dict.get(k)
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1105 self.assertIs(v, weakdict[k])
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1106 self.assertIs(v, weakdict.get(k))
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1107 for k in dict.keys():
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1108 self.assertIn(k, weakdict,
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1109 "original key disappeared in weak dict")
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1110 v = dict[k]
59783 c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1111 self.assertIs(v, weakdict[k])
c8c840162804 #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper. Florent Xicluna <florent.xicluna@gmail.com> parents: 58460 diff changeset	1112 self.assertIs(v, weakdict.get(k))
17547 6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1113
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1114 def test_weak_valued_dict_update(self):
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1115 self.check_update(weakref.WeakValueDictionary,
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1116 {1: C(), 'a': C(), C(): C()})
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1117
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1118 def test_weak_keyed_dict_update(self):
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1119 self.check_update(weakref.WeakKeyDictionary,
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1120 {C(): 1, C(): 2, C(): 3})
6252693afd9a Add a test case for WeakDictionary.update() that would have caught a Fred Drake <fdrake@acm.org>* parents: 17498 diff changeset	1121
19764 578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1122 def test_weak_keyed_delitem(self):
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1123 d = weakref.WeakKeyDictionary()
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1124 o1 = Object('1')
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1125 o2 = Object('2')
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1126 d[o1] = 'something'
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1127 d[o2] = 'something'
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1128 self.assertTrue(len(d) == 2)
19764 578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1129 del d[o1]
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1130 self.assertTrue(len(d) == 1)
6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1131 self.assertTrue(d.keys() == [o2])
19764 578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1132
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1133 def test_weak_valued_delitem(self):
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1134 d = weakref.WeakValueDictionary()
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1135 o1 = Object('1')
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1136 o2 = Object('2')
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1137 d['something'] = o1
578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1138 d['something else'] = o2
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1139 self.assertTrue(len(d) == 2)
19764 578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1140 del d['something']
55002 6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1141 self.assertTrue(len(d) == 1)
6768b2350c57 convert usage of fail* to assert* Benjamin Peterson <benjamin@python.org> parents: 49120 diff changeset	1142 self.assertTrue(d.items() == [('something else', o2)])
19764 578ef36f8fde Added tests for key deletion for both WeakDictionary flavors. Fred Drake <fdrake@acm.org>* parents: 18952 diff changeset	1143
29257 dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1144 def test_weak_keyed_bad_delitem(self):
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1145 d = weakref.WeakKeyDictionary()
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1146 o = Object('1')
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1147 # An attempt to delete an object that isn't there should raise
29258 18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1148 # KeyError. It didn't before 2.3.
29257 dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1149 self.assertRaises(KeyError, d.__delitem__, o)
29258 18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1150 self.assertRaises(KeyError, d.__getitem__, o)
18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1151
18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1152 # If a key isn't of a weakly referencable type, __getitem__ and
18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1153 # __setitem__ raise TypeError. __delitem__ should too.
18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1154 self.assertRaises(TypeError, d.__delitem__, 13)
18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1155 self.assertRaises(TypeError, d.__getitem__, 13)
18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1156 self.assertRaises(TypeError, d.__setitem__, 13, 13)
29257 dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1157
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1158 def test_weak_keyed_cascading_deletes(self):
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1159 # SF bug 742860. For some reason, before 2.3 __delitem__ iterated
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1160 # over the keys via self.data.iterkeys(). If things vanished from
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1161 # the dict during this (or got added), that caused a RuntimeError.
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1162
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1163 d = weakref.WeakKeyDictionary()
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1164 mutate = False
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1165
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1166 class C(object):
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1167 def __init__(self, i):
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1168 self.value = i
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1169 def __hash__(self):
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1170 return hash(self.value)
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1171 def __eq__(self, other):
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1172 if mutate:
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1173 # Side effect that mutates the dict, by removing the
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1174 # last strong reference to a key.
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1175 del objs[-1]
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1176 return self.value == other.value
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1177
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1178 objs = [C(i) for i in range(4)]
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1179 for o in objs:
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1180 d[o] = o.value
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1181 del o # now the only strong references to keys are in objs
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1182 # Find the order in which iterkeys sees the keys.
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1183 objs = d.keys()
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1184 # Reverse it, so that the iteration implementation of __delitem__
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1185 # has to keep looping to find the first object we delete.
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1186 objs.reverse()
29258 18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1187
29257 dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1188 # Turn on mutation in C.__eq__. The first time thru the loop,
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1189 # under the iterkeys() business the first comparison will delete
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1190 # the last item iterkeys() would see, and that causes a
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1191 # RuntimeError: dictionary changed size during iteration
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1192 # when the iterkeys() loop goes around to try comparing the next
29258 18c020463965 Fleshed out WeakKeyDictionary.__delitem__ NEWS to cover issues raised on Tim Peters <tim.peters@gmail.com> parents: 29257 diff changeset	1193 # key. After this was fixed, it just deletes the last object our
29257 dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1194 # "for o in obj" loop would have gotten to.
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1195 mutate = True
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1196 count = 0
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1197 for o in objs:
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1198 count += 1
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1199 del d[o]
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1200 self.assertEqual(len(d), 0)
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1201 self.assertEqual(count, 2)
dea38116c373 SF 742860: WeakKeyDictionary __delitem__ uses iterkeys Tim Peters <tim.peters@gmail.com> parents: 28922 diff changeset	1202
32163 fad52ffd8892 Port the dictionary tests from test_types.py to unittest. Collect as much Walter Dörwald <walter@livinglogic.de> parents: 31522 diff changeset	1203 from test import mapping_tests
28240 ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1204
32163 fad52ffd8892 Port the dictionary tests from test_types.py to unittest. Collect as much Walter Dörwald <walter@livinglogic.de> parents: 31522 diff changeset	1205 class WeakValueDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
29862 f339f29b06cb stylistic nits: Fred Drake <fdrake@acm.org> parents: 29697 diff changeset	1206 """Check that WeakValueDictionary conforms to the mapping protocol"""
28240 ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1207 __ref = {"key1":Object(1), "key2":Object(2), "key3":Object(3)}
32204 9a3901bf6222 Rename class attribute containing the class to be tested, so the name is the Walter Dörwald <walter@livinglogic.de> parents: 32163 diff changeset	1208 type2test = weakref.WeakValueDictionary
28240 ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1209 def _reference(self):
ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1210 return self.__ref.copy()
ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1211
32163 fad52ffd8892 Port the dictionary tests from test_types.py to unittest. Collect as much Walter Dörwald <walter@livinglogic.de> parents: 31522 diff changeset	1212 class WeakKeyDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
29862 f339f29b06cb stylistic nits: Fred Drake <fdrake@acm.org> parents: 29697 diff changeset	1213 """Check that WeakKeyDictionary conforms to the mapping protocol"""
28240 ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1214 __ref = {Object("key1"):1, Object("key2"):2, Object("key3"):3}
32204 9a3901bf6222 Rename class attribute containing the class to be tested, so the name is the Walter Dörwald <walter@livinglogic.de> parents: 32163 diff changeset	1215 type2test = weakref.WeakKeyDictionary
28240 ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1216 def _reference(self):
ea70032a24b1 SF patch #667730: More DictMixin Raymond Hettinger <python@rcn.com> parents: 24963 diff changeset	1217 return self.__ref.copy()
16385 1fb6672b20ef PEP 205, Weak References -- initial checkin. Fred Drake <fdrake@acm.org> parents: diff changeset	1218
47196 12c56d2eb4d9 #2592: delegate nb_index and the floor/truediv slots in weakref.proxy. Georg Brandl <georg@python.org> parents: 40707 diff changeset	1219 libreftest = """ Doctest for examples in the library reference: weakref.rst
35195 7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1220
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1221 >>> import weakref
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1222 >>> class Dict(dict):
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1223 ... pass
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1224 ...
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1225 >>> obj = Dict(red=1, green=2, blue=3) # this object is weak referencable
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1226 >>> r = weakref.ref(obj)
38464 e989ee5d404a ("Forward-port" of r46506) Armin Rigo <arigo@tunes.org> parents: 38079 diff changeset	1227 >>> print r() is obj
e989ee5d404a ("Forward-port" of r46506) Armin Rigo <arigo@tunes.org> parents: 38079 diff changeset	1228 True
35195 7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1229
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1230 >>> import weakref
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1231 >>> class Object:
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1232 ... pass
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1233 ...
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1234 >>> o = Object()
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1235 >>> r = weakref.ref(o)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1236 >>> o2 = r()
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1237 >>> o is o2
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1238 True
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1239 >>> del o, o2
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1240 >>> print r()
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1241 None
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1242
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1243 >>> import weakref
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1244 >>> class ExtendedRef(weakref.ref):
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1245 ... def __init__(self, ob, callback=None, **annotations):
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1246 ... super(ExtendedRef, self).__init__(ob, callback)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1247 ... self.__counter = 0
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1248 ... for k, v in annotations.iteritems():
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1249 ... setattr(self, k, v)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1250 ... def __call__(self):
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1251 ... '''Return a pair containing the referent and the number of
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1252 ... times the reference has been called.
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1253 ... '''
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1254 ... ob = super(ExtendedRef, self).__call__()
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1255 ... if ob is not None:
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1256 ... self.__counter += 1
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1257 ... ob = (ob, self.__counter)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1258 ... return ob
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1259 ...
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1260 >>> class A: # not in docs from here, just testing the ExtendedRef
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1261 ... pass
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1262 ...
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1263 >>> a = A()
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1264 >>> r = ExtendedRef(a, foo=1, bar="baz")
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1265 >>> r.foo
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1266 1
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1267 >>> r.bar
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1268 'baz'
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1269 >>> r()[1]
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1270 1
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1271 >>> r()[1]
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1272 2
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1273 >>> r()[0] is a
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1274 True
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1275
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1276
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1277 >>> import weakref
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1278 >>> _id2obj_dict = weakref.WeakValueDictionary()
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1279 >>> def remember(obj):
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1280 ... oid = id(obj)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1281 ... _id2obj_dict[oid] = obj
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1282 ... return oid
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1283 ...
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1284 >>> def id2obj(oid):
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1285 ... return _id2obj_dict[oid]
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1286 ...
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1287 >>> a = A() # from here, just testing
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1288 >>> a_id = remember(a)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1289 >>> id2obj(a_id) is a
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1290 True
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1291 >>> del a
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1292 >>> try:
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1293 ... id2obj(a_id)
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1294 ... except KeyError:
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1295 ... print 'OK'
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1296 ... else:
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1297 ... print 'WeakValueDictionary error'
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1298 OK
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1299
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1300 """
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1301
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1302 __test__ = {'libreftest' : libreftest}
7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1303
20013 e3184e46303b Change the PyUnit-based tests to use the test_main() approach. This Fred Drake <fdrake@acm.org> parents: 19764 diff changeset	1304 def test_main():
28917 1741af48fd9f Combine the functionality of test_support.run_unittest() Walter Dörwald <walter@livinglogic.de> parents: 28240 diff changeset	1305 test_support.run_unittest(
1741af48fd9f Combine the functionality of test_support.run_unittest() Walter Dörwald <walter@livinglogic.de> parents: 28240 diff changeset	1306 ReferencesTestCase,
1741af48fd9f Combine the functionality of test_support.run_unittest() Walter Dörwald <walter@livinglogic.de> parents: 28240 diff changeset	1307 MappingTestCase,
1741af48fd9f Combine the functionality of test_support.run_unittest() Walter Dörwald <walter@livinglogic.de> parents: 28240 diff changeset	1308 WeakValueDictionaryTestCase,
29862 f339f29b06cb stylistic nits: Fred Drake <fdrake@acm.org> parents: 29697 diff changeset	1309 WeakKeyDictionaryTestCase,
47733 4ed165940bdd Issue 3110: Crash with weakref subclass, Amaury Forgeot d'Arc <amauryfa@gmail.com> parents: 40705 diff changeset	1310 SubclassableWeakrefTestCase,
29862 f339f29b06cb stylistic nits: Fred Drake <fdrake@acm.org> parents: 29697 diff changeset	1311 )
35195 7804bbb26492 backport doctest for weakref examples Georg Brandl <georg@python.org> parents: 34847 diff changeset	1312 test_support.run_doctest(sys.modules[__name__])
20013 e3184e46303b Change the PyUnit-based tests to use the test_main() approach. This Fred Drake <fdrake@acm.org> parents: 19764 diff changeset	1313
e3184e46303b Change the PyUnit-based tests to use the test_main() approach. This Fred Drake <fdrake@acm.org> parents: 19764 diff changeset	1314
e3184e46303b Change the PyUnit-based tests to use the test_main() approach. This Fred Drake <fdrake@acm.org> parents: 19764 diff changeset	1315 if __name__ == "__main__":
e3184e46303b Change the PyUnit-based tests to use the test_main() approach. This Fred Drake <fdrake@acm.org> parents: 19764 diff changeset	1316 test_main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_weakref.py @ 79675:c0a2294de787 2.7