Lines Matching refs:self
73 def check_sanity(self):
78 def __del__(self):
84 if not self._cleaning:
85 self.del_calls.append(id(self))
86 self.check_sanity()
87 self.side_effect()
89 self.errors.append(e)
91 def side_effect(self):
99 def __init__(self):
100 self.id_ = id(self)
102 def check_sanity(self):
103 assert self.id_ == id(self)
114 def side_effect(self):
116 Resurrect self by storing self in a class-wide list.
118 self.survivors.append(self)
126 def side_effect(self):
128 Resurrect self by storing self in a class-wide list.
130 self.survivors.append(self)
135 def setUp(self):
136 self.old_garbage = gc.garbage[:]
139 def tearDown(self):
142 self.assertEqual(gc.garbage, [])
144 del self.old_garbage
147 def assert_del_calls(self, ids):
148 self.assertEqual(sorted(SimpleBase.del_calls), sorted(ids))
150 def assert_tp_del_calls(self, ids):
151 self.assertEqual(sorted(SimpleBase.tp_del_calls), sorted(ids))
153 def assert_survivors(self, ids):
154 self.assertEqual(sorted(id(x) for x in SimpleBase.survivors), sorted(ids))
156 def assert_garbage(self, ids):
157 self.assertEqual(sorted(id(x) for x in gc.garbage), sorted(ids))
159 def clear_survivors(self):
168 def test_simple(self):
175 self.assert_del_calls(ids)
176 self.assert_survivors([])
177 self.assertIs(wr(), None)
179 self.assert_del_calls(ids)
180 self.assert_survivors([])
182 def test_simple_resurrect(self):
189 self.assert_del_calls(ids)
190 self.assert_survivors(ids)
191 self.assertIsNot(wr(), None)
192 self.clear_survivors()
194 self.assert_del_calls(ids)
195 self.assert_survivors([])
196 self.assertIs(wr(), None)
199 def test_non_gc(self):
202 self.assertFalse(gc.is_tracked(s))
206 self.assert_del_calls(ids)
207 self.assert_survivors([])
209 self.assert_del_calls(ids)
210 self.assert_survivors([])
213 def test_non_gc_resurrect(self):
216 self.assertFalse(gc.is_tracked(s))
220 self.assert_del_calls(ids)
221 self.assert_survivors(ids)
222 self.clear_survivors()
224 self.assert_del_calls(ids * 2)
225 self.assert_survivors(ids)
230 def __init__(self):
232 self.ref = self
234 def check_sanity(self):
236 assert self.ref is self
246 def side_effect(self):
250 self.ref = None
259 def test_simple(self):
266 self.assert_del_calls(ids)
267 self.assert_survivors([])
268 self.assertIs(wr(), None)
270 self.assert_del_calls(ids)
271 self.assert_survivors([])
273 def test_simple_resurrect(self):
281 self.assert_del_calls(ids)
282 self.assert_survivors(ids)
284 self.assertIs(wr(), None)
287 self.clear_survivors()
289 self.assert_del_calls(ids)
290 self.assert_survivors([])
291 self.assertIs(wr(), None)
293 def test_simple_suicide(self):
302 self.assert_del_calls(ids)
303 self.assert_survivors([])
304 self.assertIs(wr(), None)
306 self.assert_del_calls(ids)
307 self.assert_survivors([])
308 self.assertIs(wr(), None)
313 def chain(self, left):
314 self.suicided = False
315 self.left = left
316 left.right = self
318 def check_sanity(self):
320 if self.suicided:
321 assert self.left is None
322 assert self.right is None
324 left = self.left
328 assert left.right is self
329 right = self.right
333 assert right.left is self
343 def side_effect(self):
347 self.suicided = True
348 self.left = None
349 self.right = None
355 spirit to the self-cycle tests above, but the collectable object
359 def build_chain(self, classes):
365 def check_non_resurrecting_chain(self, classes):
368 nodes = self.build_chain(classes)
373 self.assert_del_calls(ids)
374 self.assert_survivors([])
375 self.assertEqual([wr() for wr in wrs], [None] * N)
377 self.assert_del_calls(ids)
379 def check_resurrecting_chain(self, classes):
382 nodes = self.build_chain(classes)
389 self.assert_del_calls(ids)
390 self.assert_survivors(survivor_ids)
392 self.assertEqual([wr() for wr in wrs], [None] * N)
393 self.clear_survivors()
395 self.assert_del_calls(ids)
396 self.assert_survivors([])
398 def test_homogenous(self):
399 self.check_non_resurrecting_chain([SimpleChained] * 3)
401 def test_homogenous_resurrect(self):
402 self.check_resurrecting_chain([ChainedResurrector] * 3)
404 def test_homogenous_suicidal(self):
405 self.check_non_resurrecting_chain([SuicidalChained] * 3)
407 def test_heterogenous_suicidal_one(self):
408 self.check_non_resurrecting_chain([SuicidalChained, SimpleChained] * 2)
410 def test_heterogenous_suicidal_two(self):
411 self.check_non_resurrecting_chain(
414 def test_heterogenous_resurrect_one(self):
415 self.check_resurrecting_chain([ChainedResurrector, SimpleChained] * 2)
417 def test_heterogenous_resurrect_two(self):
418 self.check_resurrecting_chain(
421 def test_heterogenous_resurrect_three(self):
422 self.check_resurrecting_chain(
431 def __del__(self):
435 if not self._cleaning:
436 self.del_calls.append(id(self))
437 self.check_sanity()
439 self.errors.append(e)
441 def __tp_del__(self):
446 if not self._cleaning:
447 self.tp_del_calls.append(id(self))
448 self.check_sanity()
449 self.side_effect()
451 self.errors.append(e)
460 def side_effect(self):
462 Resurrect self by storing self in a class-wide list.
464 self.survivors.append(self)
477 def tearDown(self):
484 def test_legacy(self):
491 self.assert_del_calls(ids)
492 self.assert_tp_del_calls(ids)
493 self.assert_survivors([])
494 self.assertIs(wr(), None)
496 self.assert_del_calls(ids)
497 self.assert_tp_del_calls(ids)
499 def test_legacy_resurrect(self):
506 self.assert_del_calls(ids)
507 self.assert_tp_del_calls(ids)
508 self.assert_survivors(ids)
510 self.assertIs(wr(), None)
511 self.clear_survivors()
513 self.assert_del_calls(ids)
514 self.assert_tp_del_calls(ids * 2)
515 self.assert_survivors(ids)
516 self.assertIs(wr(), None)
518 def test_legacy_self_cycle(self):
526 self.assert_del_calls([])
527 self.assert_tp_del_calls([])
528 self.assert_survivors([])
529 self.assert_garbage(ids)
530 self.assertIsNot(wr(), None)
533 self.assert_garbage([])
534 self.assertIs(wr(), None)