def test_connect_in_recursive_emission_2(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.safe_connecting_recursive_handler)
test.signal.emit(0)
test.assert_results(0, 1, 2, 3, 4, 104, 103, 102, 101, 100)
def test_connect_with_keywords(self):
test = NotifyTestObject()
signal = Signal()
signal.connect_safe(test.simple_keywords_handler, a=1)
signal.connect_safe(test.simple_keywords_handler, a=2, b=3)
signal.emit()
signal.emit(b=42)
signal.emit('ham')
test.assert_results(
{'a': 1},
{
'a': 2,
'b': 3
},
# Note that emission keyword arguments must override
# connection-time keyword arguments.
{
'a': 1,
'b': 42
},
{
'a': 2,
'b': 42
},
('ham', {
'a': 1
}),
('ham', {
'a': 2,
'b': 3
}))
def test_disconnect_in_recursive_emission_2(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.self_disconnecting_recursive_handler)
test.signal.emit(0)
test.assert_results(0, 1, 2)
def test_custom_accumulator(self):
class CustomAccumulator(AbstractSignal.AbstractAccumulator):
def get_initial_value(self):
return 10
def accumulate_value(self, accumulated_value, value_to_add):
return accumulated_value + value_to_add
def should_continue(self, accumulated_value):
return accumulated_value <= 50
def post_process_value(self, accumulated_value):
return -accumulated_value
signal = Signal(CustomAccumulator())
self.assertEqual(signal.emit(), -10)
signal.connect(lambda: 15)
self.assertEqual(signal.emit(), -25)
signal.connect(lambda: 20)
self.assertEqual(signal.emit(), -45)
signal.connect(lambda: 30)
self.assertEqual(signal.emit(), -75)
# This handler should never be invoked.
signal.connect(lambda: 50)
self.assertEqual(signal.emit(), -75)
def test_handler_garbage_collection_3(self):
test = NotifyTestObject()
signal = Signal(AbstractSignal.ANY_ACCEPTS)
handler = HandlerGarbageCollectionTestCase.HandlerObject(test)
def accepting_handler(*arguments):
test.simple_handler_100(*arguments)
return arguments[0]
signal.connect(accepting_handler)
signal.connect(handler.simple_handler)
self.assertEqual(len(signal._handlers), 2)
signal.emit(1)
del handler
self.collect_garbage()
self.assertEqual(len(signal._handlers), 2)
signal.emit(2)
# This time emission is stopped by accumulator, but still the gc-collected handler
# must be removed.
self.assertEqual(len(signal._handlers), 1)
test.assert_results(101, 102)
def test_recursive_invocation_1(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.recursive_handler)
test.signal.emit(0)
test.assert_results(0, 1, 2, 3, 4)
def test_recursive_invocation_2(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.recursive_handler)
test.signal.connect(test.simple_handler_100)
test.signal.emit(0)
test.assert_results(0, 1, 2, 3, 4, 104, 103, 102, 101, 100)
def test_argument_passing(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_handler)
signal.emit(45, 'abc')
test.assert_results((45, 'abc'))
def test_disconnect_in_recursive_emission_1(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.simple_handler_100)
test.signal.connect(test.disconnecting_recursive_handler)
test.signal.emit(0)
test.assert_results(100, 0, 101, 1, 102, 2, 3, 4)
def test_emission_level_1(self):
signal = Signal(Signal.VALUE_LIST)
self.assertEqual(signal.emission_level, 0)
signal.connect(lambda: signal.emission_level)
self.assertEqual(signal.emit(), [1])
signal = Signal(Signal.VALUE_LIST)
def stop_emission_and_get_level():
signal.stop_emission()
return signal.emission_level
signal.connect(stop_emission_and_get_level)
self.assertEqual(signal.emit(), [1])
def initialize (self):
signal = Signal ()
signal.connect (_ignoring_handler)
signal.connect (_ignoring_handler, 1)
signal.connect (_ignoring_handler, 'a', 'b')
signal.connect (_ignoring_handler, None, True, False)
self.__signal = signal
def test_last_value_accumulator(self):
signal = Signal(AbstractSignal.LAST_VALUE)
self.assertEqual(signal.emit(), None)
signal.connect(lambda: 15)
self.assertEqual(signal.emit(), 15)
signal.connect(lambda: 'abc')
self.assertEqual(signal.emit(), 'abc')
def test_emission_stop_3(self):
def stop_emission():
was_stopped = signal.emission_stopped
signal.stop_emission()
return was_stopped, signal.emission_stopped
signal = Signal(Signal.VALUE_LIST)
signal.connect(stop_emission)
self.assertEqual(signal.emit(), [(False, True)])
def test_value_list_accumulator(self):
signal = Signal(AbstractSignal.VALUE_LIST)
self.assertEqual(signal.emit(), [])
signal.connect(lambda: 50)
self.assertEqual(signal.emit(), [50])
signal.connect(lambda: None)
signal.connect(lambda: ())
self.assertEqual(signal.emit(), [50, None, ()])
def test_block_in_recursive_emission_2(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.simple_handler)
test.signal.connect(lambda x: test.signal.block(test.simple_handler))
test.signal.connect(test.simple_handler)
test.signal.emit(1)
test.assert_results(1)
def test_connect(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_handler)
signal.emit()
self.assert_(signal.has_handlers())
self.assert_(signal)
test.assert_results(())
def test_block(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_handler)
signal.emit(1)
signal.block(test.simple_handler)
signal.emit(2)
test.assert_results(1)
def test_disconnect(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_handler)
signal.emit()
signal.disconnect(test.simple_handler)
signal.emit()
test.assert_results(())
def test_connecting_1(self):
test = NotifyTestObject()
signal = Signal()
signal.emit(1)
with signal.connecting(test.simple_handler):
signal.emit(2)
signal.emit(3)
test.assert_results(2)
def test_mixed_argument_passing(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_keywords_handler)
signal.emit(ham='spam')
signal.emit(42)
signal.emit(1, 2, 3, foo='bar')
test.assert_results({'ham': 'spam'}, (42, {}), (1, 2, 3, {
'foo': 'bar'
}))
def test_emission_stop_1(self):
def stop_emission():
signal.stop_emission()
test = NotifyTestObject()
signal = Signal()
signal.connect(stop_emission)
signal.connect(test.simple_handler)
signal.emit()
test.assert_results()
def test_connect_with_arguments(self):
test = NotifyTestObject()
signal = Signal()
signal.connect_safe(test.simple_handler, 'one argument')
signal.connect_safe(test.simple_handler, 'first', 'second', 3)
signal.emit()
signal.emit('a', 'b')
test.assert_results('one argument', ('first', 'second', 3),
('one argument', 'a', 'b'),
('first', 'second', 3, 'a', 'b'))
def initialize (self):
signal = Signal ()
object = _Dummy ()
signal.connect (object.ignoring_handler)
signal.connect (object.ignoring_handler, 1)
signal.connect (object.ignoring_handler, 'a', 'b')
signal.connect (object.ignoring_handler, None, True, False)
self.__signal = signal
# To keep it alive.
self.__object = object
def test_emission_level_2(self):
test = NotifyTestObject()
signal = Signal()
def reemit_if_shallow():
test.results.append(signal.emission_level)
if signal.emission_level < 3:
signal.emit()
signal.connect(reemit_if_shallow)
signal.emit()
test.assert_results(1, 2, 3)
def test_unblock_in_recursive_emission_2(self):
test = self._RecursiveTestObject(Signal())
test.signal.connect(test.simple_handler_100)
test.signal.connect(test.unblocking_recursive_handler)
test.signal.connect(test.simple_handler_100)
test.signal.block(test.simple_handler_100)
test.signal.block(test.simple_handler_100)
test.signal.emit(0)
test.assert_results(0, 1, 2, 3, 104, 4, 104, 103, 102, 101, 100)
def test_connecting_safely_2(self):
test = NotifyTestObject()
signal = Signal()
signal.emit(1)
with nested(ignoring_exceptions(),
signal.connecting_safely(test.simple_handler)):
signal.emit(2)
raise Exception
signal.emit(3)
test.assert_results(2)
def test_all_accept_accumulator(self):
signal = Signal(AbstractSignal.ALL_ACCEPT)
self.assertEqual(signal.emit(), True)
signal.connect(lambda: True)
self.assertEqual(signal.emit(), True)
signal.connect(lambda: 'I accept')
self.assertEqual(signal.emit(), 'I accept')
signal.connect(lambda: [])
self.assertEqual(signal.emit(), [])
signal.connect(lambda: True)
self.assertEqual(signal.emit(), [])
def test_any_accepts_accumulator(self):
signal = Signal(AbstractSignal.ANY_ACCEPTS)
self.assertEqual(signal.emit(), False)
signal.connect(lambda: False)
self.assertEqual(signal.emit(), False)
signal.connect(lambda: ())
self.assertEqual(signal.emit(), ())
signal.connect(lambda: 'I accept')
self.assertEqual(signal.emit(), 'I accept')
signal.connect(lambda: ())
self.assertEqual(signal.emit(), 'I accept')
def test_disconnect_all(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_handler)
signal.connect(test.simple_handler)
signal.connect(test.simple_handler)
signal.emit(1)
signal.disconnect(test.simple_handler)
signal.emit(2)
signal.disconnect_all(test.simple_handler)
signal.emit(3)
test.assert_results(1, 1, 1, 2, 2)
def test_disconnect_blocked_handler_1(self):
test = NotifyTestObject()
signal = Signal()
signal.connect(test.simple_handler)
signal.emit(1)
signal.block(test.simple_handler)
signal.emit(2)
signal.disconnect(test.simple_handler)
signal.emit(3)
signal.connect(test.simple_handler)
signal.emit(4)
test.assert_results(1, 4)
