170 lines
7.2 KiB
Python
170 lines
7.2 KiB
Python
# Note 1: The expected behavior of weakref to an instance is that it should
|
|
# return None if no other strong references to the instance exist,
|
|
# signalling that the instance can be safely garbage collected.
|
|
#
|
|
# Note 2: The expected behavior of weakref to a method is that it should
|
|
# return None if no other strong references to the parent instance exist,
|
|
# signalling that the parent instance can be safely garbage collected.
|
|
#
|
|
# Note 3: The IPython interpreter stores its own references and will
|
|
# produce results different from those of the default Python interpreter.
|
|
import callableweakref
|
|
import weakref
|
|
import unittest
|
|
|
|
|
|
class TestCallableWeakRef(unittest.TestCase):
|
|
|
|
def test_instanceDirectWeakref_dies_on_arrival(self):
|
|
'Assert that weakref works as expected'
|
|
instanceDirectWeakref = weakref.ref(Instance())
|
|
assert instanceDirectWeakref() is None
|
|
|
|
def test_instanceIndirectWeakref_dies_when_instance_dies(self):
|
|
'Assert that weakref works as expected'
|
|
instance = Instance()
|
|
instanceIndirectWeakref = weakref.ref(instance)
|
|
assert instanceIndirectWeakref() is instance
|
|
del instance
|
|
assert instanceIndirectWeakref() is None
|
|
|
|
def test_boundMethodDirectWeakref_dies_on_arrival(self):
|
|
'Assert that weakref does not work as expected'
|
|
instance = Instance()
|
|
boundMethodDirectWeakref = weakref.ref(instance.call)
|
|
assert boundMethodDirectWeakref() is None # Should be instance
|
|
|
|
def test_boundMethodIndirectWeakref_lives_when_instance_dies(self):
|
|
'Assert that weakref works as expected'
|
|
instance = Instance()
|
|
boundMethod = instance.call
|
|
boundMethodIndirectWeakref = weakref.ref(boundMethod)
|
|
assert boundMethodIndirectWeakref() is boundMethod
|
|
del instance
|
|
assert boundMethodIndirectWeakref() is boundMethod
|
|
del boundMethod
|
|
assert boundMethodIndirectWeakref() is None
|
|
|
|
def test_unboundMethodDirectWeakref_dies_on_arrival(self):
|
|
'Assert that weakref does not work as expected'
|
|
unboundMethodDirectWeakref = weakref.ref(Instance.call)
|
|
assert unboundMethodDirectWeakref() is None # Should be Instance.call
|
|
|
|
def test_unboundMethodIndirectWeakref_dies_when_unboundMethod_dies(self):
|
|
'Assert that weakref works as expected'
|
|
unboundMethod = Instance.call
|
|
unboundMethodIndirectWeakref = weakref.ref(unboundMethod)
|
|
assert unboundMethodIndirectWeakref() is unboundMethod
|
|
del unboundMethod
|
|
assert unboundMethodIndirectWeakref() is None
|
|
|
|
def test_classFunctionDirectWeakref_dies_on_arrival(self):
|
|
'Assert that weakref works as expected'
|
|
classFunctionDirectWeakref = weakref.ref(Instance())
|
|
assert classFunctionDirectWeakref() is None
|
|
|
|
def test_classFunctionIndirectWeakref_dies_when_classFunction_dies(self):
|
|
'Assert that weakref works as expected'
|
|
classFunction = Instance()
|
|
classFunctionIndirectWeakref = weakref.ref(classFunction)
|
|
assert classFunctionIndirectWeakref() is classFunction
|
|
del classFunction
|
|
assert classFunctionIndirectWeakref() is None
|
|
|
|
def test_normalFunctionDirectWeakref_dies_when_normal_function_dies(self):
|
|
'Assert that weakref works as expected'
|
|
call = lambda: None
|
|
normalFunctionDirectWeakref = weakref.ref(call)
|
|
assert normalFunctionDirectWeakref() is call
|
|
del call
|
|
assert normalFunctionDirectWeakref() is None
|
|
|
|
def test_normalFunctionIndirectWeakref_dies_when_normal_function_dies(self):
|
|
'Assert that weakref works as expected'
|
|
call = lambda: None
|
|
normalFunction = call
|
|
normalFunctionIndirectWeakref = weakref.ref(normalFunction)
|
|
assert normalFunctionIndirectWeakref() is normalFunction
|
|
del normalFunction
|
|
assert normalFunctionIndirectWeakref() is call
|
|
del call
|
|
assert normalFunctionIndirectWeakref() is None
|
|
|
|
# Assert that CallableWeakref works as expected for callables
|
|
|
|
def test_boundMethodDirectCallableWeakref_dies_when_instance_dies(self):
|
|
instance = Instance()
|
|
boundMethodDirectCallableWeakref = callableweakref.ref(instance.call)
|
|
self.assertEqual(boundMethodDirectCallableWeakref(), instance.call)
|
|
del instance
|
|
assert boundMethodDirectCallableWeakref() is None
|
|
|
|
def test_boundMethodIndirectCallableWeakref_dies_when_instance_dies(self):
|
|
instance = Instance()
|
|
boundMethod = instance.call
|
|
boundMethodIndirectCallableWeakref = callableweakref.ref(boundMethod)
|
|
self.assertEqual(boundMethodIndirectCallableWeakref(), boundMethod)
|
|
del instance
|
|
self.assertEqual(boundMethodIndirectCallableWeakref(), boundMethod)
|
|
del boundMethod
|
|
assert boundMethodIndirectCallableWeakref() is None
|
|
|
|
def test_unboundMethodDirectCallableWeakref_lives_on_arrival(self):
|
|
unboundMethodDirectCallableWeakref = callableweakref.ref(Instance.call)
|
|
self.assertEqual(unboundMethodDirectCallableWeakref(), Instance.call)
|
|
|
|
def test_unboundMethodIndirectCallableWeakref_lives_on_arrival(self):
|
|
unboundMethod = Instance.call
|
|
unboundMethodIndirectCallableWeakref = callableweakref.ref(unboundMethod)
|
|
self.assertEqual(unboundMethodIndirectCallableWeakref(), unboundMethod)
|
|
|
|
def test_classMethodIndirectCallableWeakref_lives_on_arrival(self):
|
|
classMethod = Instance.call_classmethod
|
|
classMethodIndirectCallableWeakref = callableweakref.ref(classMethod)
|
|
self.assertEqual(classMethodIndirectCallableWeakref(), classMethod)
|
|
|
|
def test_staticMethodIndirectCallableWeakref_lives_on_arrival(self):
|
|
staticMethod = Instance.call_staticmethod
|
|
staticMethodIndirectCallableWeakref = callableweakref.ref(staticMethod)
|
|
self.assertEqual(staticMethodIndirectCallableWeakref(), staticMethod)
|
|
|
|
def test_classFunctionDirectCallableWeakref_dies_on_arrival(self):
|
|
classFunctionDirectCallableWeakref = callableweakref.ref(Instance())
|
|
assert classFunctionDirectCallableWeakref() is None
|
|
|
|
def test_classFunctionIndirectCallableWeakref_dies_when_classFunction_dies(self):
|
|
classFunction = Instance()
|
|
classFunctionIndirectCallableWeakref = callableweakref.ref(classFunction)
|
|
self.assertEqual(classFunctionIndirectCallableWeakref(), classFunction.__call__)
|
|
del classFunction
|
|
assert classFunctionIndirectCallableWeakref() is None
|
|
|
|
def test_normalFunctionDirectCallableWeakref_lives_on_arrival(self):
|
|
call = lambda: None
|
|
normalFunctionDirectCallableWeakref = callableweakref.ref(call)
|
|
self.assertEqual(normalFunctionDirectCallableWeakref(), call)
|
|
|
|
def test_normalFunctionIndirectCallableWeakref_lives_on_arrival(self):
|
|
call = lambda: None
|
|
normalFunction = call
|
|
normalFunctionIndirectWeakref = callableweakref.ref(normalFunction)
|
|
self.assertEqual(normalFunctionIndirectWeakref(), normalFunction)
|
|
del normalFunction
|
|
self.assertEqual(normalFunctionIndirectWeakref(), call)
|
|
|
|
|
|
class Instance(object):
|
|
|
|
def __call__(self):
|
|
pass
|
|
|
|
def call(self):
|
|
pass
|
|
|
|
@classmethod
|
|
def call_classmethod(Class):
|
|
pass
|
|
|
|
@staticmethod
|
|
def call_staticmethod():
|
|
pass
|