Convert test_gc to use unittest.

Lib/test/test_gc.py

-from test.test_support import verify, verbose, TestFailed, vereq
+import unittest
+from test.test_support import verbose, run_unittest
 import sys
 import gc
 import weakref
 
-def expect(actual, expected, name):
-    if actual != expected:
-        raise TestFailed, "test_%s: actual %r, expected %r" % (
-            name, actual, expected)
+### Support code
+###############################################################################
         
-def expect_nonzero(actual, name):
-    if actual == 0:
-        raise TestFailed, "test_%s: unexpected zero" % name
+# Bug 1055820 has several tests of longstanding bugs involving weakrefs and
+# cyclic gc.
 
-def run_test(name, thunk):
-    if verbose:
-        print "testing %s..." % name,
-    thunk()
-    if verbose:
-        print "ok"
+# An instance of C1055820 has a self-loop, so becomes cyclic trash when
+# unreachable.
+class C1055820(object):
+    def __init__(self, i):
+        self.i = i
+        self.loop = self
+
+class GC_Detector(object):
+    # Create an instance I.  Then gc hasn't happened again so long as
+    # I.gc_happened is false.
+
+    def __init__(self):
+        self.gc_happened = False
+
+        def it_happened(ignored):
+            self.gc_happened = True
 
-def test_list():
+        # Create a piece of cyclic trash that triggers it_happened when
+        # gc collects it.
+        self.wr = weakref.ref(C1055820(666), it_happened)
+
+
+### Tests        
+###############################################################################
+        
+class GCTests(unittest.TestCase):
+    def test_list(self):
         l = []
         l.append(l)
         gc.collect()
         del l
-    expect(gc.collect(), 1, "list")
+        self.assertEqual(gc.collect(), 1)
 
-def test_dict():
+    def test_dict(self):
         d = {}
         d[1] = d
         gc.collect()
         del d
-    expect(gc.collect(), 1, "dict")
+        self.assertEqual(gc.collect(), 1)
 
-def test_tuple():
+    def test_tuple(self):
         # since tuples are immutable we close the loop with a list
         l = []
         t = (l,)
@@ -41,40 +58,40 @@ def test_tuple():
         gc.collect()
         del t
         del l
-    expect(gc.collect(), 2, "tuple")
+        self.assertEqual(gc.collect(), 2)
 
-def test_class():
+    def test_class(self):
         class A:
             pass
         A.a = A
         gc.collect()
         del A
-    expect_nonzero(gc.collect(), "class")
+        self.assertNotEqual(gc.collect(), 0)
 
-def test_newstyleclass():
+    def test_newstyleclass(self):
         class A(object):
             pass
         gc.collect()
         del A
-    expect_nonzero(gc.collect(), "staticclass")
+        self.assertNotEqual(gc.collect(), 0)
 
-def test_instance():
+    def test_instance(self):
         class A:
             pass
         a = A()
         a.a = a
         gc.collect()
         del a
-    expect_nonzero(gc.collect(), "instance")
+        self.assertNotEqual(gc.collect(), 0)
 
-def test_newinstance():
+    def test_newinstance(self):
         class A(object):
             pass
         a = A()
         a.a = a
         gc.collect()
         del a
-    expect_nonzero(gc.collect(), "newinstance")
+        self.assertNotEqual(gc.collect(), 0)
         class B(list):
             pass
         class C(B, A):
@@ -83,15 +100,15 @@ def test_newinstance():
         a.a = a
         gc.collect()
         del a
-    expect_nonzero(gc.collect(), "newinstance(2)")
+        self.assertNotEqual(gc.collect(), 0)
         del B, C
-    expect_nonzero(gc.collect(), "newinstance(3)")
+        self.assertNotEqual(gc.collect(), 0)
         A.a = A()
         del A
-    expect_nonzero(gc.collect(), "newinstance(4)")
-    expect(gc.collect(), 0, "newinstance(5)")
+        self.assertNotEqual(gc.collect(), 0)
+        self.assertEqual(gc.collect(), 0)
 
-def test_method():
+    def test_method(self):
         # Tricky: self.__init__ is a bound method, it references the instance.
         class A:
             def __init__(self):
@@ -99,9 +116,9 @@ def test_method():
         a = A()
         gc.collect()
         del a
-    expect_nonzero(gc.collect(), "method")
+        self.assertNotEqual(gc.collect(), 0)
 
-def test_finalizer():
+    def test_finalizer(self):
         # A() is uncollectable if it is part of a cycle, make sure it shows up
         # in gc.garbage.
         class A:
@@ -116,16 +133,16 @@ def test_finalizer():
         gc.collect()
         del a
         del b
-    expect_nonzero(gc.collect(), "finalizer")
+        self.assertNotEqual(gc.collect(), 0)
         for obj in gc.garbage:
             if id(obj) == id_a:
                 del obj.a
                 break
         else:
-        raise TestFailed, "didn't find obj in garbage (finalizer)"
+            self.fail("didn't find obj in garbage (finalizer)")
         gc.garbage.remove(obj)
 
-def test_finalizer_newclass():
+    def test_finalizer_newclass(self):
         # A() is uncollectable if it is part of a cycle, make sure it shows up
         # in gc.garbage.
         class A(object):
@@ -140,40 +157,40 @@ def test_finalizer_newclass():
         gc.collect()
         del a
         del b
-    expect_nonzero(gc.collect(), "finalizer")
+        self.assertNotEqual(gc.collect(), 0)
         for obj in gc.garbage:
             if id(obj) == id_a:
                 del obj.a
                 break
         else:
-        raise TestFailed, "didn't find obj in garbage (finalizer)"
+            self.fail("didn't find obj in garbage (finalizer)")
         gc.garbage.remove(obj)
 
-def test_function():
+    def test_function(self):
         # Tricky: f -> d -> f, code should call d.clear() after the exec to
         # break the cycle.
         d = {}
         exec("def f(): pass\n") in d
         gc.collect()
         del d
-    expect(gc.collect(), 2, "function")
+        self.assertEqual(gc.collect(), 2)
 
-def test_frame():
+    def test_frame(self):
         def f():
             frame = sys._getframe()
         gc.collect()
         f()
-    expect(gc.collect(), 1, "frame")
-
+        self.assertEqual(gc.collect(), 1)
 
-def test_saveall():
+    def test_saveall(self):
         # Verify that cyclic garbage like lists show up in gc.garbage if the
         # SAVEALL option is enabled.
 
         # First make sure we don't save away other stuff that just happens to
         # be waiting for collection.
         gc.collect()
-    vereq(gc.garbage, []) # if this fails, someone else created immortal trash
+        # if this fails, someone else created immortal trash
+        self.assertEqual(gc.garbage, [])
 
         L = []
         L.append(L)
@@ -185,11 +202,11 @@ def test_saveall():
         gc.collect()
         gc.set_debug(debug)
 
-    vereq(len(gc.garbage), 1)
+        self.assertEqual(len(gc.garbage), 1)
         obj = gc.garbage.pop()
-    vereq(id(obj), id_L)
+        self.assertEqual(id(obj), id_L)
 
-def test_del():
+    def test_del(self):
         # __del__ methods can trigger collection, make this to happen
         thresholds = gc.get_threshold()
         gc.enable()
@@ -204,7 +221,7 @@ def test_del():
         gc.disable()
         gc.set_threshold(*thresholds)
 
-def test_del_newclass():
+    def test_del_newclass(self):
         # __del__ methods can trigger collection, make this to happen
         thresholds = gc.get_threshold()
         gc.enable()
@@ -219,30 +236,30 @@ def test_del_newclass():
         gc.disable()
         gc.set_threshold(*thresholds)
 
-def test_get_count():
+    def test_get_count(self):
         gc.collect()
-    expect(gc.get_count(), (0, 0, 0), "get_count()")
+        self.assertEqual(gc.get_count(), (0, 0, 0))
         a = dict()
-    expect(gc.get_count(), (1, 0, 0), "get_count()")
+        self.assertEqual(gc.get_count(), (1, 0, 0))
 
-def test_collect_generations():
+    def test_collect_generations(self):
         gc.collect()
         a = dict()
         gc.collect(0)
-    expect(gc.get_count(), (0, 1, 0), "collect(0)")
+        self.assertEqual(gc.get_count(), (0, 1, 0))
         gc.collect(1)
-    expect(gc.get_count(), (0, 0, 1), "collect(1)")
+        self.assertEqual(gc.get_count(), (0, 0, 1))
         gc.collect(2)
-    expect(gc.get_count(), (0, 0, 0), "collect(1)")
+        self.assertEqual(gc.get_count(), (0, 0, 0))
 
-class Ouch:
+    def test_trashcan(self):
+        class Ouch:
             n = 0
             def __del__(self):
                 Ouch.n = Ouch.n + 1
                 if Ouch.n % 17 == 0:
                     gc.collect()
     
-def test_trashcan():
         # "trashcan" is a hack to prevent stack overflow when deallocating
         # very deeply nested tuples etc.  It works in part by abusing the
         # type pointer and refcount fields, and that can yield horrible
@@ -270,12 +287,12 @@ def test_trashcan():
                 v = {1: v, 2: Ouch()}
         gc.disable()
 
-class Boom:
+    def test_boom(self):
+        class Boom:
             def __getattr__(self, someattribute):
                 del self.attr
                 raise AttributeError
     
-def test_boom():
         a = Boom()
         b = Boom()
         a.attr = b
@@ -284,17 +301,18 @@ def test_boom():
         gc.collect()
         garbagelen = len(gc.garbage)
         del a, b
-    # a<->b are in a trash cycle now.  Collection will invoke Boom.__getattr__
-    # (to see whether a and b have __del__ methods), and __getattr__ deletes
-    # the internal "attr" attributes as a side effect.  That causes the
-    # trash cycle to get reclaimed via refcounts falling to 0, thus mutating
-    # the trash graph as a side effect of merely asking whether __del__
-    # exists.  This used to (before 2.3b1) crash Python.  Now __getattr__
-    # isn't called.
-    expect(gc.collect(), 4, "boom")
-    expect(len(gc.garbage), garbagelen, "boom")
-
-class Boom2:
+        # a<->b are in a trash cycle now.  Collection will invoke
+        # Boom.__getattr__ (to see whether a and b have __del__ methods), and
+        # __getattr__ deletes the internal "attr" attributes as a side effect.
+        # That causes the trash cycle to get reclaimed via refcounts falling to
+        # 0, thus mutating the trash graph as a side effect of merely asking
+        # whether __del__ exists.  This used to (before 2.3b1) crash Python.
+        # Now __getattr__ isn't called.
+        self.assertEqual(gc.collect(), 4)
+        self.assertEqual(len(gc.garbage), garbagelen)
+
+    def test_boom2(self):
+        class Boom2:
             def __init__(self):
                 self.x = 0
 
@@ -304,7 +322,6 @@ class Boom2:
                     del self.attr
                 raise AttributeError
     
-def test_boom2():
         a = Boom2()
         b = Boom2()
         a.attr = b
@@ -316,20 +333,20 @@ def test_boom2():
         # Much like test_boom(), except that __getattr__ doesn't break the
         # cycle until the second time gc checks for __del__.  As of 2.3b1,
         # there isn't a second time, so this simply cleans up the trash cycle.
-    # We expect a, b, a.__dict__ and b.__dict__ (4 objects) to get reclaimed
-    # this way.
-    expect(gc.collect(), 4, "boom2")
-    expect(len(gc.garbage), garbagelen, "boom2")
+        # We expect a, b, a.__dict__ and b.__dict__ (4 objects) to get
+        # reclaimed this way.
+        self.assertEqual(gc.collect(), 4)
+        self.assertEqual(len(gc.garbage), garbagelen)
 
-# boom__new and boom2_new are exactly like boom and boom2, except use
-# new-style classes.
+    def test_boom_new(self):
+        # boom__new and boom2_new are exactly like boom and boom2, except use
+        # new-style classes.
 
-class Boom_New(object):
+        class Boom_New(object):
             def __getattr__(self, someattribute):
                 del self.attr
                 raise AttributeError
     
-def test_boom_new():
         a = Boom_New()
         b = Boom_New()
         a.attr = b
@@ -338,10 +355,11 @@ def test_boom_new():
         gc.collect()
         garbagelen = len(gc.garbage)
         del a, b
-    expect(gc.collect(), 4, "boom_new")
-    expect(len(gc.garbage), garbagelen, "boom_new")
+        self.assertEqual(gc.collect(), 4)
+        self.assertEqual(len(gc.garbage), garbagelen)
 
-class Boom2_New(object):
+    def test_boom2_new(self):
+        class Boom2_New(object):
             def __init__(self):
                 self.x = 0
 
@@ -351,7 +369,6 @@ class Boom2_New(object):
                     del self.attr
                 raise AttributeError
     
-def test_boom2_new():
         a = Boom2_New()
         b = Boom2_New()
         a.attr = b
@@ -360,57 +377,33 @@ def test_boom2_new():
         gc.collect()
         garbagelen = len(gc.garbage)
         del a, b
-    expect(gc.collect(), 4, "boom2_new")
-    expect(len(gc.garbage), garbagelen, "boom2_new")
+        self.assertEqual(gc.collect(), 4)
+        self.assertEqual(len(gc.garbage), garbagelen)
 
-def test_get_referents():
+    def test_get_referents(self):
         alist = [1, 3, 5]
         got = gc.get_referents(alist)
         got.sort()
-    expect(got, alist, "get_referents")
+        self.assertEqual(got, alist)
 
         atuple = tuple(alist)
         got = gc.get_referents(atuple)
         got.sort()
-    expect(got, alist, "get_referents")
+        self.assertEqual(got, alist)
 
         adict = {1: 3, 5: 7}
         expected = [1, 3, 5, 7]
         got = gc.get_referents(adict)
         got.sort()
-    expect(got, expected, "get_referents")
+        self.assertEqual(got, expected)
 
         got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
         got.sort()
-    expect(got, [0, 0] + range(5), "get_referents")
+        self.assertEqual(got, [0, 0] + range(5))
 
-    expect(gc.get_referents(1, 'a', 4j), [], "get_referents")
+        self.assertEqual(gc.get_referents(1, 'a', 4j), [])
 
-# Bug 1055820 has several tests of longstanding bugs involving weakrefs and
-# cyclic gc.
-
-# An instance of C1055820 has a self-loop, so becomes cyclic trash when
-# unreachable.
-class C1055820(object):
-    def __init__(self, i):
-        self.i = i
-        self.loop = self
-
-class GC_Detector(object):
-    # Create an instance I.  Then gc hasn't happened again so long as
-    # I.gc_happened is false.
-
-    def __init__(self):
-        self.gc_happened = False
-
-        def it_happened(ignored):
-            self.gc_happened = True
-
-        # Create a piece of cyclic trash that triggers it_happened when
-        # gc collects it.
-        self.wr = weakref.ref(C1055820(666), it_happened)
-
-def test_bug1055820b():
+    def test_bug1055820b(self):
         # Corresponds to temp2b.py in the bug report.
 
         ouch = []
@@ -422,20 +415,28 @@ def test_bug1055820b():
         c = None
 
         gc.collect()
-    expect(len(ouch), 0, "bug1055820b")
+        self.assertEqual(len(ouch), 0)
         # Make the two instances trash, and collect again.  The bug was that
         # the callback materialized a strong reference to an instance, but gc
         # cleared the instance's dict anyway.
         Cs = None
         gc.collect()
-    expect(len(ouch), 2, "bug1055820b")  # else the callbacks didn't run
+        self.assertEqual(len(ouch), 2)  # else the callbacks didn't run
         for x in ouch:
             # If the callback resurrected one of these guys, the instance
             # would be damaged, with an empty __dict__.
-        expect(x, None, "bug1055820b")
+            self.assertEqual(x, None)
+
+class GCTogglingTests(unittest.TestCase):
+    def setUp(self):
+        gc.enable()
         
-def test_bug1055820c():
-    # Corresponds to temp2c.py in the bug report.  This is pretty elaborate.
+    def tearDown(self):
+        gc.disable()
+    
+    def test_bug1055820c(self):
+        # Corresponds to temp2c.py in the bug report.  This is pretty
+        # elaborate.
 
         c0 = C1055820(0)
         # Move c0 into generation 2.
@@ -458,11 +459,11 @@ def test_bug1055820c():
         c0 = c1 = c2 = None
 
         # What we've set up:  c0, c1, and c2 are all trash now.  c0 is in
-    # generation 2.  The only thing keeping it alive is that c1 points to it.
-    # c1 and c2 are in generation 0, and are in self-loops.  There's a global
-    # weakref to c2 (c2wr), but that weakref has no callback.  There's also
-    # a global weakref to c0 (c0wr), and that does have a callback, and that
-    # callback references c2 via c2wr().
+        # generation 2.  The only thing keeping it alive is that c1 points to
+        # it. c1 and c2 are in generation 0, and are in self-loops.  There's a
+        # global weakref to c2 (c2wr), but that weakref has no callback.
+        # There's also a global weakref to c0 (c0wr), and that does have a
+        # callback, and that callback references c2 via c2wr().
         #
         #               c0 has a wr with callback, which references c2wr
         #               ^
@@ -476,14 +477,14 @@ def test_bug1055820c():
         #            |  |    |  |
         #            <--v    <--v
         #
-    # So this is the nightmare:  when generation 0 gets collected, we see that
-    # c2 has a callback-free weakref, and c1 doesn't even have a weakref.
-    # Collecting generation 0 doesn't see c0 at all, and c0 is the only object
-    # that has a weakref with a callback.  gc clears c1 and c2.  Clearing c1
-    # has the side effect of dropping the refcount on c0 to 0, so c0 goes
-    # away (despite that it's in an older generation) and c0's wr callback
-    # triggers.  That in turn materializes a reference to c2 via c2wr(), but
-    # c2 gets cleared anyway by gc.
+        # So this is the nightmare:  when generation 0 gets collected, we see
+        # that c2 has a callback-free weakref, and c1 doesn't even have a
+        # weakref.  Collecting generation 0 doesn't see c0 at all, and c0 is
+        # the only object that has a weakref with a callback.  gc clears c1
+        # and c2.  Clearing c1 has the side effect of dropping the refcount on
+        # c0 to 0, so c0 goes away (despite that it's in an older generation)
+        # and c0's wr callback triggers.  That in turn materializes a reference
+        # to c2 via c2wr(), but c2 gets cleared anyway by gc.
 
         # We want to let gc happen "naturally", to preserve the distinction
         # between generations.
@@ -493,17 +494,17 @@ def test_bug1055820c():
         while not detector.gc_happened:
             i += 1
             if i > 10000:
-            raise TestFailed("gc didn't happen after 10000 iterations")
-        expect(len(ouch), 0, "bug1055820c")
+                self.fail("gc didn't happen after 10000 iterations")
+            self.assertEqual(len(ouch), 0)
             junk.append([])  # this will eventually trigger gc
 
-    expect(len(ouch), 1, "bug1055820c")  # else the callback wasn't invoked
+        self.assertEqual(len(ouch), 1)  # else the callback wasn't invoked
         for x in ouch:
             # If the callback resurrected c2, the instance would be damaged,
             # with an empty __dict__.
-        expect(x, None, "bug1055820c")
+            self.assertEqual(x, None)
 
-def test_bug1055820d():
+    def test_bug1055820d(self):
         # Corresponds to temp2d.py in the bug report.  This is very much like
         # test_bug1055820c, but uses a __del__ method instead of a weakref
         # callback to sneak in a resurrection of cyclic trash.
@@ -527,10 +528,10 @@ def test_bug1055820d():
         d0 = c1 = c2 = None
 
         # What we've set up:  d0, c1, and c2 are all trash now.  d0 is in
-    # generation 2.  The only thing keeping it alive is that c1 points to it.
-    # c1 and c2 are in generation 0, and are in self-loops.  There's a global
-    # weakref to c2 (c2wr), but that weakref has no callback.  There are no
-    # other weakrefs.
+        # generation 2.  The only thing keeping it alive is that c1 points to
+        # it.  c1 and c2 are in generation 0, and are in self-loops.  There's
+        # a global weakref to c2 (c2wr), but that weakref has no callback.
+        # There are no other weakrefs.
         #
         #               d0 has a __del__ method that references c2wr
         #               ^
@@ -544,13 +545,13 @@ def test_bug1055820d():
         #            |  |    |  |
         #            <--v    <--v
         #
-    # So this is the nightmare:  when generation 0 gets collected, we see that
-    # c2 has a callback-free weakref, and c1 doesn't even have a weakref.
-    # Collecting generation 0 doesn't see d0 at all.  gc clears c1 and c2.
-    # Clearing c1 has the side effect of dropping the refcount on d0 to 0, so
-    # d0 goes away (despite that it's in an older generation) and d0's __del__
-    # triggers.  That in turn materializes a reference to c2 via c2wr(), but
-    # c2 gets cleared anyway by gc.
+        # So this is the nightmare:  when generation 0 gets collected, we see
+        # that c2 has a callback-free weakref, and c1 doesn't even have a
+        # weakref.  Collecting generation 0 doesn't see d0 at all.  gc clears
+        # c1 and c2.  Clearing c1 has the side effect of dropping the refcount
+        # on d0 to 0, so d0 goes away (despite that it's in an older
+        # generation) and d0's __del__ triggers.  That in turn materializes
+        # a reference to c2 via c2wr(), but c2 gets cleared anyway by gc.
 
         # We want to let gc happen "naturally", to preserve the distinction
         # between generations.
@@ -560,67 +561,26 @@ def test_bug1055820d():
         while not detector.gc_happened:
             i += 1
             if i > 10000:
-            raise TestFailed("gc didn't happen after 10000 iterations")
-        expect(len(ouch), 0, "bug1055820d")
+                self.fail("gc didn't happen after 10000 iterations")
+            self.assertEqual(len(ouch), 0)
             junk.append([])  # this will eventually trigger gc
 
-    expect(len(ouch), 1, "bug1055820d")  # else __del__ wasn't invoked
+        self.assertEqual(len(ouch), 1)  # else __del__ wasn't invoked
         for x in ouch:
             # If __del__ resurrected c2, the instance would be damaged, with an
             # empty __dict__.
-        expect(x, None, "bug1055820d")
-
-
-def test_all():
-    gc.collect() # Delete 2nd generation garbage
-    run_test("lists", test_list)
-    run_test("dicts", test_dict)
-    run_test("tuples", test_tuple)
-    run_test("classes", test_class)
-    run_test("new style classes", test_newstyleclass)
-    run_test("instances", test_instance)
-    run_test("new instances", test_newinstance)
-    run_test("methods", test_method)
-    run_test("functions", test_function)
-    run_test("frames", test_frame)
-    run_test("finalizers", test_finalizer)
-    run_test("finalizers (new class)", test_finalizer_newclass)
-    run_test("__del__", test_del)
-    run_test("__del__ (new class)", test_del_newclass)
-    run_test("get_count()", test_get_count)
-    run_test("collect(n)", test_collect_generations)
-    run_test("saveall", test_saveall)
-    run_test("trashcan", test_trashcan)
-    run_test("boom", test_boom)
-    run_test("boom2", test_boom2)
-    run_test("boom_new", test_boom_new)
-    run_test("boom2_new", test_boom2_new)
-    run_test("get_referents", test_get_referents)
-    run_test("bug1055820b", test_bug1055820b)
-
-    gc.enable()
-    try:
-        run_test("bug1055820c", test_bug1055820c)
-    finally:
-        gc.disable()
+            self.assertEqual(x, None)
 
-    gc.enable()
-    try:
-        run_test("bug1055820d", test_bug1055820d)
-    finally:
-        gc.disable()
-
-def test():
-    if verbose:
-        print "disabling automatic collection"
+def test_main():
     enabled = gc.isenabled()
     gc.disable()
-    verify(not gc.isenabled())
+    assert not gc.isenabled()
     debug = gc.get_debug()
     gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
 
     try:
-        test_all()
+        gc.collect() # Delete 2nd generation garbage
+        run_unittest(GCTests, GCTogglingTests)
     finally:
         gc.set_debug(debug)
         # test gc.enable() even if GC is disabled by default
@@ -628,9 +588,9 @@ def test():
             print "restoring automatic collection"
         # make sure to always test gc.enable()
         gc.enable()
-        verify(gc.isenabled())
+        assert gc.isenabled()
         if not enabled:
             gc.disable()
     
-
-test()
+if __name__ == "__main__":
+    test_main()