Lines Matching refs:gc
10 import gc
36 # cyclic gc.
46 # Create an instance I. Then gc hasn't happened again so long as
56 # gc collects it.
65 cycle have __del__ methods, the gc refuses to guess an order,
90 gc.collect()
92 self.assertEqual(gc.collect(), 1)
97 gc.collect()
99 self.assertEqual(gc.collect(), 1)
106 gc.collect()
109 self.assertEqual(gc.collect(), 2)
115 gc.collect()
117 self.assertNotEqual(gc.collect(), 0)
122 gc.collect()
124 self.assertNotEqual(gc.collect(), 0)
131 gc.collect()
133 self.assertNotEqual(gc.collect(), 0)
140 gc.collect()
142 self.assertNotEqual(gc.collect(), 0)
149 gc.collect()
151 self.assertNotEqual(gc.collect(), 0)
153 self.assertNotEqual(gc.collect(), 0)
156 self.assertNotEqual(gc.collect(), 0)
157 self.assertEqual(gc.collect(), 0)
165 gc.collect()
167 self.assertNotEqual(gc.collect(), 0)
172 # in gc.garbage.
183 gc.collect()
186 self.assertNotEqual(gc.collect(), 0)
187 for obj in gc.garbage:
193 gc.garbage.remove(obj)
198 # in gc.garbage.
209 gc.collect()
212 self.assertNotEqual(gc.collect(), 0)
213 for obj in gc.garbage:
219 gc.garbage.remove(obj)
226 gc.collect()
228 self.assertEqual(gc.collect(), 2)
234 import gc
285 gc.collect()
301 gc.collect()
303 self.assertEqual(gc.collect(), 1)
306 # Verify that cyclic garbage like lists show up in gc.garbage if the
311 gc.collect()
313 self.assertEqual(gc.garbage, [])
319 debug = gc.get_debug()
320 gc.set_debug(debug | gc.DEBUG_SAVEALL)
322 gc.collect()
323 gc.set_debug(debug)
325 self.assertEqual(len(gc.garbage), 1)
326 obj = gc.garbage.pop()
331 thresholds = gc.get_threshold()
332 gc.enable()
333 gc.set_threshold(1)
341 gc.disable()
342 gc.set_threshold(*thresholds)
346 thresholds = gc.get_threshold()
347 gc.enable()
348 gc.set_threshold(1)
356 gc.disable()
357 gc.set_threshold(*thresholds)
367 gc.collect()
368 a, b, c = gc.get_count()
370 d, e, f = gc.get_count()
381 gc.collect()
385 gc.collect(0)
387 a, b, c = gc.get_count()
388 gc.collect(1)
390 d, e, f = gc.get_count()
391 gc.collect(2)
393 g, h, i = gc.get_count()
406 gc.collect()
411 # problems when gc tries to traverse the structures.
415 # Note: In 2.3 the possibility for compiling without cyclic gc was
421 gc.enable()
433 gc.disable()
491 gc.collect()
505 gc.collect()
506 garbagelen = len(gc.garbage)
515 self.assertEqual(gc.collect(), 2)
516 self.assertEqual(len(gc.garbage), garbagelen)
534 gc.collect()
535 garbagelen = len(gc.garbage)
538 # cycle until the second time gc checks for __del__. As of 2.3b1,
542 self.assertEqual(gc.collect(), 2)
543 self.assertEqual(len(gc.garbage), garbagelen)
559 gc.collect()
560 garbagelen = len(gc.garbage)
562 self.assertEqual(gc.collect(), 2)
563 self.assertEqual(len(gc.garbage), garbagelen)
581 gc.collect()
582 garbagelen = len(gc.garbage)
584 self.assertEqual(gc.collect(), 2)
585 self.assertEqual(len(gc.garbage), garbagelen)
589 got = gc.get_referents(alist)
594 got = gc.get_referents(atuple)
600 got = gc.get_referents(adict)
604 got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
608 self.assertEqual(gc.get_referents(1, 'a', 4j), [])
615 self.assertFalse(gc.is_tracked(None))
616 self.assertFalse(gc.is_tracked(1))
617 self.assertFalse(gc.is_tracked(1.0))
618 self.assertFalse(gc.is_tracked(1.0 + 5.0j))
619 self.assertFalse(gc.is_tracked(True))
620 self.assertFalse(gc.is_tracked(False))
621 self.assertFalse(gc.is_tracked(b"a"))
622 self.assertFalse(gc.is_tracked("a"))
623 self.assertFalse(gc.is_tracked(bytearray(b"a")))
624 self.assertFalse(gc.is_tracked(type))
625 self.assertFalse(gc.is_tracked(int))
626 self.assertFalse(gc.is_tracked(object))
627 self.assertFalse(gc.is_tracked(object()))
647 self.assertTrue(gc.is_tracked(gc))
648 self.assertTrue(gc.is_tracked(UserClass))
649 self.assertTrue(gc.is_tracked(UserClass()))
650 self.assertTrue(gc.is_tracked(UserInt()))
651 self.assertTrue(gc.is_tracked([]))
652 self.assertTrue(gc.is_tracked(set()))
653 self.assertTrue(gc.is_tracked(UserClassSlots()))
654 self.assertTrue(gc.is_tracked(UserFloatSlots()))
655 self.assertTrue(gc.is_tracked(UserIntSlots()))
658 # Objects not tracked by the always gc return false
659 self.assertFalse(gc.is_finalized(3))
667 self.assertFalse(gc.is_finalized(lazarus))
670 gc.collect()
673 self.assertTrue(gc.is_finalized(lazarus))
686 gc.collect()
689 # the callback materialized a strong reference to an instance, but gc
692 gc.collect()
709 gc.collect()
729 gc.collect() # this blows up (bad C pointer) when it fails
736 import gc
751 gc.set_debug(%s)
765 self.assertIn(b"ResourceWarning: gc: 2 uncollectable objects at "
769 stderr = run_command(code % "gc.DEBUG_UNCOLLECTABLE")
770 self.assertIn(b"ResourceWarning: gc: 2 uncollectable objects at "
776 # (because gc.garbage also contains normally reclaimable cyclic
778 stderr = run_command(code % "gc.DEBUG_SAVEALL")
828 stats = gc.get_stats()
838 if gc.isenabled():
839 self.addCleanup(gc.enable)
840 gc.disable()
841 old = gc.get_stats()
842 gc.collect(0)
843 new = gc.get_stats()
847 gc.collect(2)
848 new = gc.get_stats()
854 gc.freeze()
855 self.assertGreater(gc.get_freeze_count(), 0)
856 gc.unfreeze()
857 self.assertEqual(gc.get_freeze_count(), 0)
860 gc.collect()
864 any(l is element for element in gc.get_objects(generation=0))
867 any(l is element for element in gc.get_objects(generation=1))
870 any(l is element for element in gc.get_objects(generation=2))
872 gc.collect(generation=0)
874 any(l is element for element in gc.get_objects(generation=0))
877 any(l is element for element in gc.get_objects(generation=1))
880 any(l is element for element in gc.get_objects(generation=2))
882 gc.collect(generation=1)
884 any(l is element for element in gc.get_objects(generation=0))
887 any(l is element for element in gc.get_objects(generation=1))
890 any(l is element for element in gc.get_objects(generation=2))
892 gc.collect(generation=2)
894 any(l is element for element in gc.get_objects(generation=0))
897 any(l is element for element in gc.get_objects(generation=1))
900 any(l is element for element in gc.get_objects(generation=2))
903 gc.collect()
906 gc.collect()
907 self.assertEqual(len(gc.get_objects()),
908 len(gc.get_objects(generation=None)))
910 self.assertRaises(ValueError, gc.get_objects, 1000)
911 self.assertRaises(ValueError, gc.get_objects, -1000)
912 self.assertRaises(TypeError, gc.get_objects, "1")
913 self.assertRaises(TypeError, gc.get_objects, 1.234)
928 gc.collect()
929 gc.disable()
938 gc.collect()
946 gc.collect()
949 gc.enable()
962 gc.collect()
963 gc.disable()
976 gc.collect()
982 gc.collect()
983 gc.enable()
1003 d = gc.get_stats()[-1]
1006 gc.collect()
1007 gc.disable()
1013 t = gc.collect()
1023 t = gc.collect()
1034 t = gc.collect()
1044 t = gc.collect()
1050 gc.enable()
1101 gc.collect()
1102 gc.disable()
1105 gc.collect()
1109 gc.enable()
1114 # Save gc state and disable it.
1115 self.enabled = gc.isenabled()
1116 gc.disable()
1117 self.debug = gc.get_debug()
1118 gc.set_debug(0)
1119 gc.callbacks.append(self.cb1)
1120 gc.callbacks.append(self.cb2)
1124 # Restore gc state
1126 gc.callbacks.remove(self.cb1)
1127 gc.callbacks.remove(self.cb2)
1128 gc.set_debug(self.debug)
1130 gc.enable()
1132 gc.collect()
1133 for obj in gc.garbage:
1136 del gc.garbage[:]
1138 gc.collect()
1145 gc.collect()
1146 garbage, gc.garbage[:] = gc.garbage[:], []
1157 uc = [e for e in gc.garbage if isinstance(e, Uncollectable)]
1158 gc.garbage[:] = [e for e in gc.garbage
1165 gc.collect()
1192 gc.collect(2)
1204 gc.collect()
1212 # We should now have the Uncollectables in gc.garbage
1213 self.assertEqual(len(gc.garbage), 4)
1214 for e in gc.garbage:
1220 gc.garbage[:] = []
1221 gc.collect()
1230 self.assertEqual(len(gc.garbage), 0)
1290 gc.enable()
1293 gc.disable()
1301 gc.collect()
1341 # the only object that has a weakref with a callback. gc clears c1
1345 # to c2 via c2wr(), but c2 gets cleared anyway by gc.
1347 # We want to let gc happen "naturally", to preserve the distinction
1355 self.fail("gc didn't happen after 10000 iterations")
1357 junk.append([]) # this will eventually trigger gc
1377 gc.collect()
1408 # weakref. Collecting generation 0 doesn't see d0 at all. gc clears
1412 # a reference to c2 via c2wr(), but c2 gets cleared anyway by gc.
1414 # We want to let gc happen "naturally", to preserve the distinction
1422 self.fail("gc didn't happen after 10000 iterations")
1424 junk.append([]) # this will eventually trigger gc
1462 enabled = gc.isenabled()
1463 gc.disable()
1464 assert not gc.isenabled()
1465 debug = gc.get_debug()
1466 gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
1467 gc.collect() # Delete 2nd generation garbage
1471 gc.set_debug(debug)
1472 # test gc.enable() even if GC is disabled by default
1475 # make sure to always test gc.enable()
1476 gc.enable()
1477 assert gc.isenabled()
1479 gc.disable()