Lines Matching defs:gc
4 import gc
11 # cyclic gc.
21 # Create an instance I. Then gc hasn't happened again so long as
31 # gc collects it.
42 gc.collect()
44 self.assertEqual(gc.collect(), 1)
49 gc.collect()
51 self.assertEqual(gc.collect(), 1)
58 gc.collect()
61 self.assertEqual(gc.collect(), 2)
67 gc.collect()
69 self.assertNotEqual(gc.collect(), 0)
74 gc.collect()
76 self.assertNotEqual(gc.collect(), 0)
83 gc.collect()
85 self.assertNotEqual(gc.collect(), 0)
92 gc.collect()
94 self.assertNotEqual(gc.collect(), 0)
101 gc.collect()
103 self.assertNotEqual(gc.collect(), 0)
105 self.assertNotEqual(gc.collect(), 0)
108 self.assertNotEqual(gc.collect(), 0)
109 self.assertEqual(gc.collect(), 0)
117 gc.collect()
119 self.assertNotEqual(gc.collect(), 0)
123 # in gc.garbage.
133 gc.collect()
136 self.assertNotEqual(gc.collect(), 0)
137 for obj in gc.garbage:
143 gc.garbage.remove(obj)
147 # in gc.garbage.
157 gc.collect()
160 self.assertNotEqual(gc.collect(), 0)
161 for obj in gc.garbage:
167 gc.garbage.remove(obj)
174 gc.collect()
176 self.assertEqual(gc.collect(), 2)
181 gc.collect()
183 self.assertEqual(gc.collect(), 1)
186 # Verify that cyclic garbage like lists show up in gc.garbage if the
191 gc.collect()
193 self.assertEqual(gc.garbage, [])
199 debug = gc.get_debug()
200 gc.set_debug(debug | gc.DEBUG_SAVEALL)
202 gc.collect()
203 gc.set_debug(debug)
205 self.assertEqual(len(gc.garbage), 1)
206 obj = gc.garbage.pop()
211 thresholds = gc.get_threshold()
212 gc.enable()
213 gc.set_threshold(1)
221 gc.disable()
222 gc.set_threshold(*thresholds)
226 thresholds = gc.get_threshold()
227 gc.enable()
228 gc.set_threshold(1)
236 gc.disable()
237 gc.set_threshold(*thresholds)
248 gc.collect()
249 assertEqual(gc.get_count(), (0, 0, 0))
251 # since gc.collect(), we created two objects:
253 assertEqual(gc.get_count(), (2, 0, 0))
258 gc.collect()
260 gc.collect(0)
261 assertEqual(gc.get_count(), (0, 1, 0))
262 gc.collect(1)
263 assertEqual(gc.get_count(), (0, 0, 1))
264 gc.collect(2)
265 assertEqual(gc.get_count(), (0, 0, 0))
273 gc.collect()
278 # problems when gc tries to traverse the structures.
282 # Note: In 2.3 the possibility for compiling without cyclic gc was
288 gc.enable()
300 gc.disable()
313 gc.collect()
314 garbagelen = len(gc.garbage)
323 self.assertEqual(gc.collect(), 4)
324 self.assertEqual(len(gc.garbage), garbagelen)
342 gc.collect()
343 garbagelen = len(gc.garbage)
346 # cycle until the second time gc checks for __del__. As of 2.3b1,
350 self.assertEqual(gc.collect(), 4)
351 self.assertEqual(len(gc.garbage), garbagelen)
367 gc.collect()
368 garbagelen = len(gc.garbage)
370 self.assertEqual(gc.collect(), 4)
371 self.assertEqual(len(gc.garbage), garbagelen)
389 gc.collect()
390 garbagelen = len(gc.garbage)
392 self.assertEqual(gc.collect(), 4)
393 self.assertEqual(len(gc.garbage), garbagelen)
397 got = gc.get_referents(alist)
402 got = gc.get_referents(atuple)
408 got = gc.get_referents(adict)
412 got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
416 self.assertEqual(gc.get_referents(1, 'a', 4j), [])
423 self.assertFalse(gc.is_tracked(None))
424 self.assertFalse(gc.is_tracked(1))
425 self.assertFalse(gc.is_tracked(1.0))
426 self.assertFalse(gc.is_tracked(1.0 + 5.0j))
427 self.assertFalse(gc.is_tracked(True))
428 self.assertFalse(gc.is_tracked(False))
429 self.assertFalse(gc.is_tracked("a"))
430 self.assertFalse(gc.is_tracked(u"a"))
431 self.assertFalse(gc.is_tracked(bytearray("a")))
432 self.assertFalse(gc.is_tracked(type))
433 self.assertFalse(gc.is_tracked(int))
434 self.assertFalse(gc.is_tracked(object))
435 self.assertFalse(gc.is_tracked(object()))
441 self.assertTrue(gc.is_tracked(gc))
442 self.assertTrue(gc.is_tracked(OldStyle))
443 self.assertTrue(gc.is_tracked(OldStyle()))
444 self.assertTrue(gc.is_tracked(NewStyle))
445 self.assertTrue(gc.is_tracked(NewStyle()))
446 self.assertTrue(gc.is_tracked([]))
447 self.assertTrue(gc.is_tracked(set()))
460 gc.collect()
463 # the callback materialized a strong reference to an instance, but gc
466 gc.collect()
475 gc.enable()
478 gc.disable()
486 gc.collect()
526 # the only object that has a weakref with a callback. gc clears c1
530 # to c2 via c2wr(), but c2 gets cleared anyway by gc.
532 # We want to let gc happen "naturally", to preserve the distinction
540 self.fail("gc didn't happen after 10000 iterations")
542 junk.append([]) # this will eventually trigger gc
562 gc.collect()
593 # weakref. Collecting generation 0 doesn't see d0 at all. gc clears
597 # a reference to c2 via c2wr(), but c2 gets cleared anyway by gc.
599 # We want to let gc happen "naturally", to preserve the distinction
607 self.fail("gc didn't happen after 10000 iterations")
609 junk.append([]) # this will eventually trigger gc
618 enabled = gc.isenabled()
619 gc.disable()
620 assert not gc.isenabled()
621 debug = gc.get_debug()
622 gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
625 gc.collect() # Delete 2nd generation garbage
628 gc.set_debug(debug)
629 # test gc.enable() even if GC is disabled by default
632 # make sure to always test gc.enable()
633 gc.enable()
634 assert gc.isenabled()
636 gc.disable()