diff options
Diffstat (limited to 'Lib/test')
| -rw-r--r-- | Lib/test/output/test_weakref | 21 | ||||
| -rw-r--r-- | Lib/test/test_weakref.py | 218 |
2 files changed, 239 insertions, 0 deletions
diff --git a/Lib/test/output/test_weakref b/Lib/test/output/test_weakref new file mode 100644 index 0000000..b3d6f97 --- /dev/null +++ b/Lib/test/output/test_weakref @@ -0,0 +1,21 @@ +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 + +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 new file mode 100644 index 0000000..fe19373 --- /dev/null +++ b/Lib/test/test_weakref.py @@ -0,0 +1,218 @@ +import sys +import weakref + +from test_support import TestFailed, verify + + +class C: + pass + + +print "Basic Weak References" + +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 + + +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") + + +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") + + +print "-- Re-use of weak reference objects" +print " reference objects" + +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") + +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") + +print " proxy objects" + +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 clearing1(r): + print "clearing ref 1" + +def clearing2(r): + print "clearing ref 2" + +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 + +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 + +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 + +print +print "Weak Valued Dictionaries" + +class Object: + def __init__(self, arg): + self.arg = arg + 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!") +dict.clear() +print "weak dict test complete" + +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") |