def testHandleErrorOnCallback(self, monkeypatch): self.called = 0 def After(*args, **kwargs): self.called += 1 raise RuntimeError('test') def After2(*args, **kwargs): self.called += 1 raise RuntimeError('test2') c = callback.Callback(handle_errors=True) c.Register(After) c.Register(After2) error_handled_on = [] def MyHandleException(msg): error_handled_on.append(msg) monkeypatch.setattr(handle_exception, 'HandleException', MyHandleException) c() assert len(error_handled_on) == 2 assert self.called == 2 c(1, a=2) assert len(error_handled_on) == 4 assert self.called == 4 # test the default behaviour: errors are not handled and stop execution as usual self.called = 0 c = callback.Callback() c.Register(After) c.Register(After2) with pytest.raises(RuntimeError): c() assert self.called == 1
def testCallbackReceiverDies(self): class A: def on_foo(dummy, *args): # @NoSelf self.args = args self.args = None a = A() weak_a = weakref.ref(a) foo = callback.Callback() foo.Register(a.on_foo) foo(1, 2) assert self.args == (1, 2) assert weak_a() is a foo(3, 4) assert self.args == (3, 4) assert weak_a() is a del a assert weak_a() is None foo(5, 6) assert self.args == (3, 4)
def testExtraArgs(self): ''' Tests the extra-args parameter in Callback.Register method. ''' self.zulu_calls = [] def zulu_one(*args): self.zulu_calls.append(args) def zulu_too(*args): self.zulu_calls.append(args) alpha = callback.Callback() alpha.Register(zulu_one, [1, 2]) assert self.zulu_calls == [] alpha('a') assert self.zulu_calls == [(1, 2, 'a')] alpha('a', 'b', 'c') assert self.zulu_calls, [(1, 2, 'a'), (1, 2, 'a', 'b', 'c')] # Test a second method with extra-args alpha.Register(zulu_too, [9]) alpha('a') assert self.zulu_calls == [(1, 2, 'a'), (1, 2, 'a', 'b', 'c'), (1, 2, 'a'), (9, 'a'), ]
def testCallback(self): self.args = [None, None] def f1(*args): self.args[0] = args def f2(*args): 'Never called!' my_callback = callback.Callback() assert len(my_callback) == 0 my_callback.Register(f1) assert len(my_callback) == 1 my_callback(1, 2) assert self.args[0] == (1, 2) my_callback.Unregister(f1) self.args[0] = None my_callback(10, 20) assert self.args[0] is None def foo(): pass my_callback.Unregister(foo) # Not raises
def testNeedsUnregister(self): c = callback.Callback() # Even when the function isn't registered, we not raise an error. def Func(): 'Never called!' # self.assertNotRaises(RuntimeError, c.Unregister(Func)
def testRegisterTwice(self): self.called = 0 def After(*args): self.called += 1 c = callback.Callback() c.Register(After) c.Register(After) c.Register(After) c() assert self.called == 1
def testContains(self): def foo(x): 'Never called!' c = callback.Callback() assert not c.Contains(foo) c.Register(foo) assert c.Contains(foo) c.Unregister(foo) assert not c.Contains(foo)
def testErrorNotHandledInCallback(self, monkeypatch): class MyError(ErrorNotHandledInCallback): pass def After(*args, **kwargs): raise MyError() c = callback.Callback(handle_errors=True) c.Register(After) with pytest.raises(MyError): c()
def testUnregisterAll(self): c = callback.Callback() # self.assertNotRaises(AttributeError, c.UnregisterAll() self.called = 0 def Func(): self.called += 1 c.Register(Func) c() assert self.called == 1 c.UnregisterAll() c() assert self.called == 1
def testAfterRemoveCallback(self): my_object = _MyClass() my_object.SetAlpha(0) my_object.SetBravo(0) # Test After/Remove with a callback event = callback.Callback() callback.After(my_object.SetAlpha, event) event.Register(my_object.SetBravo) my_object.SetAlpha(3) assert my_object.bravo == 3 callback.Remove(my_object.SetAlpha, event) my_object.SetAlpha(4) assert my_object.bravo == 3
def testRemoveCallback(self): class C(object): def __init__(self, name): self.name = name def OnCallback(self): 'Never called!' def __eq__(self, other): return self.name == other.name def __ne__(self, other): ''' Never called! return not self == other ''' instance1 = C('instance') instance2 = C('instance') assert instance1 == instance2 c = callback.Callback() c.Register(instance1.OnCallback) c.Register(instance2.OnCallback) # removing first callback, and checking that it was actually removed as expected c.Unregister(instance1.OnCallback) assert c.Contains(instance1.OnCallback) == False # self.assertNotRaises(RuntimeError, c.Unregister(instance1.OnCallback) # removing second callback, and checking that it was actually removed as expected c.Unregister(instance2.OnCallback) assert c.Contains(instance2.OnCallback) == False # self.assertNotRaises(RuntimeError c.Unregister(instance2.OnCallback)
def testKeyReusedAfterDead(self, monkeypatch): self._gotten_key = False def GetKey(*args, **kwargs): self._gotten_key = True return 1 monkeypatch.setattr(callback.Callback, '_GetKey', GetKey) def AfterMethod(*args): 'Not called!' def AfterMethodB(*args): 'Not called!' c = callback.Callback() c.Register(AfterMethod) self._gotten_key = False assert not c.Contains(AfterMethodB) assert c.Contains(AfterMethod) assert self._gotten_key # As we made _GetKey return always the same, this will make it remove one and add the # other one, so, the contains will have to check if they're actually the same or not. c.Register(AfterMethodB) self._gotten_key = False assert c.Contains(AfterMethodB) assert not c.Contains(AfterMethod) assert self._gotten_key class A(object): def __init__(self): self._a = 0 def GetA(self): return self._a def SetA(self, value): self._a = value a = property(GetA, SetA) a = A() # Coverage exercise assert a.a == 0 a.a = 10 assert a.a == 10 # If registering a bound, it doesn't contain the unbound c.Register(a.SetA) assert not c.Contains(AfterMethodB) assert not c.Contains(A.SetA) assert c.Contains(a.SetA) # But if registering an unbound, it contains the bound c.Register(A.SetA) assert not c.Contains(AfterMethodB) assert c.Contains(A.SetA) assert c.Contains(a.SetA) c.Register(a.SetA) assert len(c) == 1 del a assert not c.Contains(AfterMethodB) assert len(c) == 0 a = A() c.Register(_CallbackWrapper(WeakMethodRef(a.SetA))) assert len(c) == 1 del a assert not c.Contains(AfterMethodB) assert len(c) == 0