Lines Matching refs:gc
5 import gc
17 # cyclic gc.
27 # Create an instance I. Then gc hasn't happened again so long as
37 # gc collects it.
48 gc.collect()
50 self.assertEqual(gc.collect(), 1)
55 gc.collect()
57 self.assertEqual(gc.collect(), 1)
64 gc.collect()
67 self.assertEqual(gc.collect(), 2)
73 gc.collect()
75 self.assertNotEqual(gc.collect(), 0)
80 gc.collect()
82 self.assertNotEqual(gc.collect(), 0)
89 gc.collect()
91 self.assertNotEqual(gc.collect(), 0)
98 gc.collect()
100 self.assertNotEqual(gc.collect(), 0)
107 gc.collect()
109 self.assertNotEqual(gc.collect(), 0)
111 self.assertNotEqual(gc.collect(), 0)
114 self.assertNotEqual(gc.collect(), 0)
115 self.assertEqual(gc.collect(), 0)
123 gc.collect()
125 self.assertNotEqual(gc.collect(), 0)
129 # in gc.garbage.
139 gc.collect()
142 self.assertNotEqual(gc.collect(), 0)
143 for obj in gc.garbage:
149 gc.garbage.remove(obj)
153 # in gc.garbage.
163 gc.collect()
166 self.assertNotEqual(gc.collect(), 0)
167 for obj in gc.garbage:
173 gc.garbage.remove(obj)
180 gc.collect()
182 self.assertEqual(gc.collect(), 2)
187 gc.collect()
189 self.assertEqual(gc.collect(), 1)
192 # Verify that cyclic garbage like lists show up in gc.garbage if the
197 gc.collect()
199 self.assertEqual(gc.garbage, [])
205 debug = gc.get_debug()
206 gc.set_debug(debug | gc.DEBUG_SAVEALL)
208 gc.collect()
209 gc.set_debug(debug)
211 self.assertEqual(len(gc.garbage), 1)
212 obj = gc.garbage.pop()
217 thresholds = gc.get_threshold()
218 gc.enable()
219 gc.set_threshold(1)
227 gc.disable()
228 gc.set_threshold(*thresholds)
232 thresholds = gc.get_threshold()
233 gc.enable()
234 gc.set_threshold(1)
242 gc.disable()
243 gc.set_threshold(*thresholds)
254 gc.collect()
255 assertEqual(gc.get_count(), (0, 0, 0))
257 # since gc.collect(), we created two objects:
259 assertEqual(gc.get_count(), (2, 0, 0))
264 gc.collect()
266 gc.collect(0)
267 assertEqual(gc.get_count(), (0, 1, 0))
268 gc.collect(1)
269 assertEqual(gc.get_count(), (0, 0, 1))
270 gc.collect(2)
271 assertEqual(gc.get_count(), (0, 0, 0))
279 gc.collect()
284 # problems when gc tries to traverse the structures.
288 # Note: In 2.3 the possibility for compiling without cyclic gc was
294 gc.enable()
306 gc.disable()
368 gc.collect()
382 gc.collect()
383 garbagelen = len(gc.garbage)
392 self.assertEqual(gc.collect(), 4)
393 self.assertEqual(len(gc.garbage), garbagelen)
411 gc.collect()
412 garbagelen = len(gc.garbage)
415 # cycle until the second time gc checks for __del__. As of 2.3b1,
419 self.assertEqual(gc.collect(), 4)
420 self.assertEqual(len(gc.garbage), garbagelen)
436 gc.collect()
437 garbagelen = len(gc.garbage)
439 self.assertEqual(gc.collect(), 4)
440 self.assertEqual(len(gc.garbage), garbagelen)
458 gc.collect()
459 garbagelen = len(gc.garbage)
461 self.assertEqual(gc.collect(), 4)
462 self.assertEqual(len(gc.garbage), garbagelen)
466 got = gc.get_referents(alist)
471 got = gc.get_referents(atuple)
477 got = gc.get_referents(adict)
481 got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
485 self.assertEqual(gc.get_referents(1, 'a', 4j), [])
492 self.assertFalse(gc.is_tracked(None))
493 self.assertFalse(gc.is_tracked(1))
494 self.assertFalse(gc.is_tracked(1.0))
495 self.assertFalse(gc.is_tracked(1.0 + 5.0j))
496 self.assertFalse(gc.is_tracked(True))
497 self.assertFalse(gc.is_tracked(False))
498 self.assertFalse(gc.is_tracked("a"))
499 self.assertFalse(gc.is_tracked(u"a"))
500 self.assertFalse(gc.is_tracked(bytearray("a")))
501 self.assertFalse(gc.is_tracked(type))
502 self.assertFalse(gc.is_tracked(int))
503 self.assertFalse(gc.is_tracked(object))
504 self.assertFalse(gc.is_tracked(object()))
510 self.assertTrue(gc.is_tracked(gc))
511 self.assertTrue(gc.is_tracked(OldStyle))
512 self.assertTrue(gc.is_tracked(OldStyle()))
513 self.assertTrue(gc.is_tracked(NewStyle))
514 self.assertTrue(gc.is_tracked(NewStyle()))
515 self.assertTrue(gc.is_tracked([]))
516 self.assertTrue(gc.is_tracked(set()))
529 gc.collect()
532 # the callback materialized a strong reference to an instance, but gc
535 gc.collect()
544 gc.enable()
547 gc.disable()
555 gc.collect()
595 # the only object that has a weakref with a callback. gc clears c1
599 # to c2 via c2wr(), but c2 gets cleared anyway by gc.
601 # We want to let gc happen "naturally", to preserve the distinction
609 self.fail("gc didn't happen after 10000 iterations")
611 junk.append([]) # this will eventually trigger gc
631 gc.collect()
662 # weakref. Collecting generation 0 doesn't see d0 at all. gc clears
666 # a reference to c2 via c2wr(), but c2 gets cleared anyway by gc.
668 # We want to let gc happen "naturally", to preserve the distinction
676 self.fail("gc didn't happen after 10000 iterations")
678 junk.append([]) # this will eventually trigger gc
687 enabled = gc.isenabled()
688 gc.disable()
689 assert not gc.isenabled()
690 debug = gc.get_debug()
691 gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
694 gc.collect() # Delete 2nd generation garbage
697 gc.set_debug(debug)
698 # test gc.enable() even if GC is disabled by default
701 # make sure to always test gc.enable()
702 gc.enable()
703 assert gc.isenabled()
705 gc.disable()
