def test_garbage_collection_3(self):
test = NotifyTestObject()
variable = Variable()
condition1 = variable.is_true()
condition2 = ~condition1
condition2.store(test.simple_handler)
condition1 = weakref.ref(condition1)
condition2 = weakref.ref(condition2)
self.collect_garbage()
self.assertNotEqual(condition1(), None)
self.assertNotEqual(condition2(), None)
self.collect_garbage()
variable.value = 10
condition2().changed.disconnect(test.simple_handler)
self.collect_garbage()
self.assertEqual(condition1(), None)
self.assertEqual(condition2(), None)
variable = weakref.ref(variable)
self.collect_garbage()
self.assertEqual(variable(), None)
test.assert_results(True, False)
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_garbage_collection_binary(self):
for _operator in (operator.__and__, operator.__or__, operator.__xor__):
test = NotifyTestObject()
condition1 = Condition(True)
condition2 = Condition(False)
binary_condition = _operator(condition1, condition2)
binary_condition.store(test.simple_handler)
binary_condition = weakref.ref(binary_condition)
del condition1
self.collect_garbage()
self.assertNotEqual(binary_condition(), None)
condition2.state = True
del condition2
self.collect_garbage()
self.assertEqual(binary_condition(), None)
expected_results = []
for state1, state2 in ((True, False), (True, True)):
if not expected_results or expected_results[-1] != _operator(
state1, state2):
expected_results.append(_operator(state1, state2))
test.assert_results(*expected_results)
def test_internals_1(self):
test = NotifyTestObject()
condition = Condition(False)
not_condition = ~condition
self.assert_(not not_condition._has_signal())
not_condition.changed.connect(test.simple_handler)
self.assert_(not_condition._has_signal())
def set_state_true():
condition.state = True
condition.with_changes_frozen(set_state_true)
condition.state = False
not_condition.changed.disconnect(test.simple_handler)
self.collect_garbage()
self.assert_(not not_condition._has_signal())
not_condition.changed.connect(test.simple_handler)
self.assert_(not_condition._has_signal())
condition.state = True
test.assert_results(False, True, False)
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_garbage_collection_if_else(self):
test = NotifyTestObject()
condition1 = Condition(False)
condition2 = Condition(False)
condition3 = Condition(True)
if_else_condition = condition1.if_else(condition2, condition3)
if_else_condition.store(test.simple_handler)
if_else_condition = weakref.ref(if_else_condition)
del condition2
self.collect_garbage()
self.assertNotEqual(if_else_condition(), None)
condition3.state = False
del condition1
self.collect_garbage()
self.assertNotEqual(if_else_condition(), None)
condition3.state = True
del condition3
self.collect_garbage()
self.assertEqual(if_else_condition(), None)
test.assert_results(True, False, True)
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_predicate_condition_2(self):
test = NotifyTestObject()
predicate = PredicateCondition(bool, None)
predicate.store(test.simple_handler)
predicate.update(False)
test.assert_results(False)
def test_with_changes_frozen_1(self):
test = NotifyTestObject()
variable = Variable()
variable.changed.connect(test.simple_handler)
variable.with_changes_frozen(lambda: None)
# Must not emit `changed' signal: no changes at all.
test.assert_results()
def test_changes_frozen_2(self):
test = NotifyTestObject()
variable = Variable()
variable.changed.connect(test.simple_handler)
with variable.changes_frozen():
variable.value = 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_predicate_condition_3(self):
test = NotifyTestObject()
predicate = PredicateCondition(lambda x: x > 10, 0)
predicate.store(test.simple_handler)
predicate.update(10)
predicate.update(20)
predicate.update(-5)
test.assert_results(False, True, False)
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_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_changes_frozen_4(self):
test = NotifyTestObject()
variable = Variable()
variable.changed.connect(test.simple_handler)
with variable.changes_frozen():
variable.value = 1
variable.value = None
# Must not emit: value returned to original.
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_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_storing_1(self):
test = NotifyTestObject()
variable = Variable()
variable.value = 100
with variable.storing(test.simple_handler):
variable.value = 200
variable.value = 300
test.assert_results(100, 200)
def test_if_else_2(self):
test = NotifyTestObject()
condition1 = Condition(False)
condition2 = Condition(False)
condition3 = Condition(True)
if_else_condition = condition1.if_else(condition2, condition3)
if_else_condition.store(test.simple_handler)
condition1.state = True
test.assert_results(True, False)
def test_not(self):
test = NotifyTestObject()
condition = Condition(False)
not_condition = ~condition
not_condition.store(test.simple_handler)
self.assertEqual(not_condition.state, True)
condition.state = True
self.assertEqual(not_condition.state, False)
test.assert_results(True, False)
def test_with_changes_frozen_3(self):
test = NotifyTestObject()
variable = Variable()
variable.changed.connect(test.simple_handler)
def do_changes():
variable.value = 1
variable.value = 2
variable.with_changes_frozen(do_changes)
test.assert_results(2)
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_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 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_storing_2(self):
test = NotifyTestObject()
variable = Variable()
variable.value = 100
with nested(ignoring_exceptions(),
variable.storing(test.simple_handler)):
variable.value = 200
raise Exception
variable.value = 300
test.assert_results(100, 200)
def test_watcher_condition_1(self):
test = NotifyTestObject()
watcher = WatcherCondition()
watcher.store(test.simple_handler)
condition = Condition(True)
watcher.watch(condition)
self.assert_(watcher.watched_condition is condition)
condition.state = False
test.assert_results(False, True, False)
def test_derivation_3(self):
test = NotifyTestObject()
DerivedCondition = \
AbstractStateTrackingCondition.derive_type ('DerivedCondition',
setter = (lambda condition, state:
test.simple_handler (state)))
condition = DerivedCondition(False)
condition.set(True)
condition.state = False
# There is no getter at all, so setter must be called during condition creation.
test.assert_results(False, True, False)
def test_derived_variable_changes_frozen_1(self):
DerivedVariable = AbstractVariable.derive_type(
'DerivedVariable', getter=lambda variable: x)
test = NotifyTestObject()
x = 1
variable = DerivedVariable()
variable.store(test.simple_handler)
with variable.changes_frozen():
x = 2
# Though we never call _value_changed(), changes_frozen() promises to call it
# itself in such cases.
test.assert_results(1, 2)
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)
