diff --git a/Lib/test/output/test_weakref b/Lib/test/output/test_weakref
index ef74e7e..8575763 100644
--- a/Lib/test/output/test_weakref
+++ b/Lib/test/output/test_weakref
@@ -1,25 +1 @@
 test_weakref
-Basic Weak References
--- Liveness and referent identity
--- Reference objects with callbacks
--- Proxy objects with callbacks
--- Re-use of weak reference objects
-     reference objects
-     proxy objects
-clearing ref 2
-clearing ref 1
-clearing ref 2
-clearing ref 1
-
-Weak Valued Dictionaries
-objects are stored in weak dict
-weak dict test complete
-
-Weak Keyed Dictionaries
-objects are stored in weak dict
-weak key dict test complete
-
-Non-callable Proxy References
-XXX -- tests not written!
-
-Callable Proxy References
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index a468575..1e193f1 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -1,137 +1,202 @@
 import sys
+import unittest
 import weakref
 
-from test_support import TestFailed, verify
+from test_support import run_unittest, verify
 
 
 class C:
-    pass
+    def method(self):
+        pass
 
 
-print "Basic Weak References"
+class Callable:
+    bar = None
 
-print "-- Liveness and referent identity"
-
-o = C()
-ref = weakref.ref(o)
-verify(ref() is not None, "weak reference to live object should be live")
-o2 = ref()
-verify(ref() is not None, "weak ref should still be live")
-verify(o is o2, "<ref>() should return original object if live")
-del o, o2
-del ref
-
-cbcalled = 0
-def callback(o):
-    global cbcalled
-    cbcalled = 1
-
-o = C()
-ref2 = weakref.ref(o, callback)
-del o
-verify(cbcalled,
-       "callback did not properly set 'cbcalled'")
-verify(ref2() is None,
-       "ref2 should be dead after deleting object reference")
-del ref2
+    def __call__(self, x):
+        self.bar = x
 
 
-print "-- Reference objects with callbacks"
-o = C()
-o.bar = 1
-ref1 = weakref.ref(o, id)
-ref2 = weakref.ref(o, id)
-del o
-verify(ref1() is None,
-       "expected reference to be invalidated")
-verify(ref2() is None,
-       "expected reference to be invalidated")
+def create_function():
+    def f(): pass
+    return f
+
+def create_bound_method():
+    return C().method
+
+def create_unbound_method():
+    return C.method
 
 
-print "-- Proxy objects with callbacks"
-o = C()
-o.bar = 1
-ref1 = weakref.proxy(o, id)
-ref2 = weakref.proxy(o, id)
-del o
-try:
-    ref1.bar
-except weakref.ReferenceError:
-    pass
-else:
-    raise TestFailed("expected ReferenceError exception")
-try:
-    ref2.bar
-except weakref.ReferenceError:
-    pass
-else:
-    raise TestFailed("expected ReferenceError exception")
+class TestBase(unittest.TestCase):
+
+    def setUp(self):
+        self.cbcalled = 0
+
+    def callback(self, ref):
+        self.cbcalled += 1
 
 
-print "-- Re-use of weak reference objects"
-print "     reference objects"
+class ReferencesTestCase(TestBase):
 
-o = C()
-ref1 = weakref.ref(o)
-# create a proxy to make sure that there's an intervening creation
-# between these two; it should make no difference
-proxy = weakref.proxy(o)
-ref2 = weakref.ref(o)
-verify(ref1 is ref2,
-       "reference object w/out callback should have been re-used")
+    def test_basic_ref(self):
+        self.check_basic_ref(C)
+        self.check_basic_ref(create_function)
+        self.check_basic_ref(create_bound_method)
+        self.check_basic_ref(create_unbound_method)
 
-o = C()
-proxy = weakref.proxy(o)
-ref1 = weakref.ref(o)
-ref2 = weakref.ref(o)
-verify(ref1 is ref2,
-       "reference object w/out callback should have been re-used")
-verify(weakref.getweakrefcount(o) == 2,
-       "wrong weak ref count for object")
-del proxy
-verify(weakref.getweakrefcount(o) == 1,
-       "wrong weak ref count for object after deleting proxy")
+    def test_basic_callback(self):
+        self.check_basic_callback(C)
+        self.check_basic_callback(create_function)
+        self.check_basic_callback(create_bound_method)
+        self.check_basic_callback(create_unbound_method)
 
-print "     proxy objects"
+    def test_multiple_callbacks(self):
+        o = C()
+        ref1 = weakref.ref(o, self.callback)
+        ref2 = weakref.ref(o, self.callback)
+        del o
+        self.assert_(ref1() is None,
+                     "expected reference to be invalidated")
+        self.assert_(ref2() is None,
+                     "expected reference to be invalidated")
+        self.assert_(self.cbcalled == 2,
+                     "callback not called the right number of times")
 
-o = C()
-ref3 = weakref.proxy(o)
-ref4 = weakref.proxy(o)
-verify(ref3 is ref4,
-       "proxy object w/out callback should have been re-used")
+    def test_proxy_ref(self):
+        o = C()
+        o.bar = 1
+        ref1 = weakref.proxy(o, self.callback)
+        ref2 = weakref.proxy(o, self.callback)
+        del o
 
+        def check(proxy):
+            proxy.bar
 
-def clearing1(r):
-    print "clearing ref 1"
+        self.assertRaises(weakref.ReferenceError, check, ref1)
+        self.assertRaises(weakref.ReferenceError, check, ref2)
+        self.assert_(self.cbcalled == 2)
 
-def clearing2(r):
-    print "clearing ref 2"
+    def check_basic_ref(self, factory):
+        o = factory()
+        ref = weakref.ref(o)
+        self.assert_(ref() is not None,
+                     "weak reference to live object should be live")
+        o2 = ref()
+        self.assert_(o is o2,
+                     "<ref>() should return original object if live")
 
-o = C()
-ref1 = weakref.ref(o, clearing1)
-ref2 = weakref.ref(o, clearing2)
-verify(weakref.getweakrefcount(o) == 2,
-       "got wrong number of weak reference objects")
-del o
+    def check_basic_callback(self, factory):
+        self.cbcalled = 0
+        o = factory()
+        ref = weakref.ref(o, self.callback)
+        del o
+        verify(self.cbcalled == 1,
+               "callback did not properly set 'cbcalled'")
+        verify(ref() is None,
+               "ref2 should be dead after deleting object reference")
 
-o = C()
-ref1 = weakref.ref(o, clearing1)
-ref2 = weakref.ref(o, clearing2)
-del ref1
-verify(weakref.getweakrefs(o) == [ref2],
-       "list of refs does not match")
-del o
+    def test_ref_reuse(self):
+        o = C()
+        ref1 = weakref.ref(o)
+        # create a proxy to make sure that there's an intervening creation
+        # between these two; it should make no difference
+        proxy = weakref.proxy(o)
+        ref2 = weakref.ref(o)
+        self.assert_(ref1 is ref2,
+                     "reference object w/out callback should be re-used")
 
-o = C()
-ref1 = weakref.ref(o, clearing1)
-ref2 = weakref.ref(o, clearing2)
-del ref2
-verify(weakref.getweakrefs(o) == [ref1],
-       "list of refs does not match")
-del o
+        o = C()
+        proxy = weakref.proxy(o)
+        ref1 = weakref.ref(o)
+        ref2 = weakref.ref(o)
+        self.assert_(ref1 is ref2,
+                     "reference object w/out callback should be re-used")
+        self.assert_(weakref.getweakrefcount(o) == 2,
+                     "wrong weak ref count for object")
+        del proxy
+        self.assert_(weakref.getweakrefcount(o) == 1,
+                     "wrong weak ref count for object after deleting proxy")
 
-print
-print "Weak Valued Dictionaries"
+    def test_proxy_reuse(self):
+        o = C()
+        proxy1 = weakref.proxy(o)
+        ref = weakref.ref(o)
+        proxy2 = weakref.proxy(o)
+        self.assert_(proxy1 is proxy2,
+                     "proxy object w/out callback should have been re-used")
+
+    def test_basic_proxy(self):
+        o = C()
+        self.check_proxy(o, weakref.proxy(o))
+
+    def test_callable_proxy(self):
+        o = Callable()
+        ref1 = weakref.proxy(o)
+
+        self.check_proxy(o, ref1)
+
+        self.assert_(type(ref1) is weakref.CallableProxyType,
+                     "proxy is not of callable type")
+        ref1('twinkies!')
+        self.assert_(o.bar == 'twinkies!',
+                     "call through proxy not passed through to original")
+
+        # expect due to too few args
+        self.assertRaises(TypeError, ref1)
+
+        # expect due to too many args
+        self.assertRaises(TypeError, ref1, 1, 2, 3)
+
+    def check_proxy(self, o, proxy):
+        o.foo = 1
+        self.assert_(proxy.foo == 1,
+                     "proxy does not reflect attribute addition")
+        o.foo = 2
+        self.assert_(proxy.foo == 2,
+                     "proxy does not reflect attribute modification")
+        del o.foo
+        self.assert_(not hasattr(proxy, 'foo'),
+                     "proxy does not reflect attribute removal")
+
+        proxy.foo = 1
+        self.assert_(o.foo == 1,
+                     "object does not reflect attribute addition via proxy")
+        proxy.foo = 2
+        self.assert_(
+            o.foo == 2,
+            "object does not reflect attribute modification via proxy")
+        del proxy.foo
+        self.assert_(not hasattr(o, 'foo'),
+                     "object does not reflect attribute removal via proxy")
+
+    def test_getweakrefcount(self):
+        o = C()
+        ref1 = weakref.ref(o)
+        ref2 = weakref.ref(o, self.callback)
+        self.assert_(weakref.getweakrefcount(o) == 2,
+                     "got wrong number of weak reference objects")
+
+        proxy1 = weakref.proxy(o)
+        proxy2 = weakref.proxy(o, self.callback)
+        self.assert_(weakref.getweakrefcount(o) == 4,
+                     "got wrong number of weak reference objects")
+
+    def test_getweakrefs(self):
+        o = C()
+        ref1 = weakref.ref(o, self.callback)
+        ref2 = weakref.ref(o, self.callback)
+        del ref1
+        self.assert_(weakref.getweakrefs(o) == [ref2],
+                     "list of refs does not match")
+
+        o = C()
+        ref1 = weakref.ref(o, self.callback)
+        ref2 = weakref.ref(o, self.callback)
+        del ref2
+        self.assert_(weakref.getweakrefs(o) == [ref1],
+                     "list of refs does not match")
+
 
 class Object:
     def __init__(self, arg):
@@ -139,112 +204,63 @@
     def __repr__(self):
         return "<Object %r>" % self.arg
 
-dict = weakref.mapping()
-objects = map(Object, range(10))
-for o in objects:
-    dict[o.arg] = o
-print "objects are stored in weak dict"
-for o in objects:
-    verify(weakref.getweakrefcount(o) == 1,
-           "wrong number of weak references to %r!" % o)
-    verify(o is dict[o.arg],
-           "wrong object returned by weak dict!")
-items1 = dict.items()
-items2 = dict.copy().items()
-items1.sort()
-items2.sort()
-verify(items1 == items2,
-       "cloning of weak-valued dictionary did not work!")
-del items1, items2
-dict.clear()
-print "weak dict test complete"
 
-print
-print "Weak Keyed Dictionaries"
+class MappingTestCase(TestBase):
 
-dict = weakref.mapping(weakkeys=1)
-objects = map(Object, range(10))
-for o in objects:
-    dict[o] = o.arg
-print "objects are stored in weak dict"
-for o in objects:
-    verify(weakref.getweakrefcount(o) == 1,
-           "wrong number of weak references to %r!" % o)
-    verify(o.arg is dict[o],
-           "wrong object returned by weak dict!")
-items1 = dict.items()
-items2 = dict.copy().items()
-items1.sort()
-items2.sort()
-verify(items1 == items2,
-       "cloning of weak-keyed dictionary did not work!")
-del items1, items2
-del objects, o
-verify(len(dict)==0, "deleting the keys did not clear the dictionary")
-print "weak key dict test complete"
+    COUNT = 10
+
+    def test_weak_values(self):
+        dict = weakref.mapping()
+        objects = map(Object, range(self.COUNT))
+        for o in objects:
+            dict[o.arg] = o
+
+        for o in objects:
+            self.assert_(weakref.getweakrefcount(o) == 1,
+                         "wrong number of weak references to %r!" % o)
+            self.assert_(o is dict[o.arg],
+                         "wrong object returned by weak dict!")
+        items1 = dict.items()
+        items2 = dict.copy().items()
+        items1.sort()
+        items2.sort()
+        self.assert_(items1 == items2,
+                     "cloning of weak-valued dictionary did not work!")
+        del items1, items2
+        self.assert_(len(dict) == self.COUNT)
+        del objects[0]
+        self.assert_(len(dict) == (self.COUNT - 1),
+                     "deleting object did not cause dictionary update")
+        del objects, o
+        self.assert_(len(dict) == 0,
+                     "deleting the values did not clear the dictionary")
+
+    def test_weak_keys(self):
+        dict = weakref.mapping(weakkeys=1)
+        objects = map(Object, range(self.COUNT))
+        for o in objects:
+            dict[o] = o.arg
+
+        for o in objects:
+            self.assert_(weakref.getweakrefcount(o) == 1,
+                         "wrong number of weak references to %r!" % o)
+            self.assert_(o.arg is dict[o],
+                         "wrong object returned by weak dict!")
+        items1 = dict.items()
+        items2 = dict.copy().items()
+        items1.sort()
+        items2.sort()
+        self.assert_(items1 == items2,
+                     "cloning of weak-keyed dictionary did not work!")
+        del items1, items2
+        self.assert_(len(dict) == self.COUNT)
+        del objects[0]
+        self.assert_(len(dict) == (self.COUNT - 1),
+                     "deleting object did not cause dictionary update")
+        del objects, o
+        self.assert_(len(dict) == 0,
+                     "deleting the keys did not clear the dictionary")
 
 
-print
-print "Non-callable Proxy References"
-print "XXX -- tests not written!"
-
-
-def test_proxy(o, proxy):
-    o.foo = 1
-    verify(proxy.foo == 1,
-           "proxy does not reflect attribute addition")
-    o.foo = 2
-    verify(proxy.foo == 2,
-           "proxy does not reflect attribute modification")
-    del o.foo
-    verify(not hasattr(proxy, 'foo'),
-           "proxy does not reflect attribute removal")
-
-    proxy.foo = 1
-    verify(o.foo == 1,
-           "object does not reflect attribute addition via proxy")
-    proxy.foo = 2
-    verify(o.foo == 2,
-           "object does not reflect attribute modification via proxy")
-    del proxy.foo
-    verify(not hasattr(o, 'foo'),
-           "object does not reflect attribute removal via proxy")
-
-
-o = C()
-test_proxy(o, weakref.proxy(o))
-
-print
-print "Callable Proxy References"
-
-class Callable:
-    bar = None
-    def __call__(self, x):
-        self.bar = x
-
-o = Callable()
-ref1 = weakref.proxy(o)
-
-test_proxy(o, ref1)
-
-verify(type(ref1) is weakref.CallableProxyType,
-       "proxy is not of callable type")
-ref1('twinkies!')
-verify(o.bar == 'twinkies!',
-       "call through proxy not passed through to original")
-
-try:
-    ref1()
-except TypeError:
-    # expect due to too few args
-    pass
-else:
-    raise TestFailed("did not catch expected TypeError -- too few args")
-
-try:
-    ref1(1, 2, 3)
-except TypeError:
-    # expect due to too many args
-    pass
-else:
-    raise TestFailed("did not catch expected TypeError -- too many args")
+run_unittest(ReferencesTestCase)
+run_unittest(MappingTestCase)