def __init__(self,
unittest,
generator,
signal_name,
should_be_caught=True,
how_many_signals=1,
error_code="No error code set"):
self.signal_catched_event = threading.Event()
self.generator = generator
self.signal_name = signal_name
self.signal_arguments = []
self.unittest = unittest
self.how_many_signals = how_many_signals
self.should_be_caught = should_be_caught
self.error_code = error_code
def _on_failure():
# we need to release the waiting thread
self.signal_catched_event.set()
self.missed = True
# then we notify the error
# if the error_code is set to None, we're expecting it to fail.
if error_code is not None:
print("An expected signal wasn't received %s" % error_code)
self.unittest.assertFalse(should_be_caught)
self.watchdog = Watchdog(3, _on_failure)
class CallbackCatcher(object):
"""
A class to test callbacks
"""
def __init__(self, unittest, generator, signal_name,\
should_be_caught = True, how_many_signals = 1, \
error_code = "No error code set"):
self.signal_catched_event = threading.Event()
self.generator = generator
self.signal_name = signal_name
self.signal_arguments = []
self.unittest = unittest
self.how_many_signals = how_many_signals
self.should_be_caught = should_be_caught
self.error_code = error_code
def _on_failure():
#we need to release the waiting thread
self.signal_catched_event.set()
self.missed = True
#then we notify the error
#if the error_code is set to None, we're expecting it to fail.
if error_code != None:
print("An expected signal wasn't received {0!s}".format(
error_code
))
self.unittest.assertFalse(should_be_caught)
self.watchdog = Watchdog(3, _on_failure)
def __enter__(self):
def __signal_callback(*args):
"""
Difference to SignalCatcher is that we do not skip
the first argument. The first argument by signals is widget
which sends the signal -- we omit this feature when using callbacks
"""
self.signal_arguments.append(args)
if len(self.signal_arguments) >= self.how_many_signals:
self.signal_catched_event.set()
self.handler = self.generator.register_cllbck(
self.signal_name, __signal_callback
)
self.watchdog.__enter__()
return [self.signal_catched_event, self.signal_arguments]
def __exit__(self, err_type, value, traceback):
self.generator.deregister_cllbck(self.signal_name, self.handler)
if not self.should_be_caught and not hasattr(self, 'missed'):
self.assertFalse(True)
return not isinstance(value, Exception) and \
self.watchdog.__exit__(err_type, value, traceback)
class CallbackCatcher(object):
"""
A class to test callbacks
"""
def __init__(
self,
unittest,
generator,
signal_name,
should_be_caught=True,
how_many_signals=1,
error_code="No error code set",
):
self.signal_catched_event = threading.Event()
self.generator = generator
self.signal_name = signal_name
self.signal_arguments = []
self.unittest = unittest
self.how_many_signals = how_many_signals
self.should_be_caught = should_be_caught
self.error_code = error_code
def _on_failure():
# we need to release the waiting thread
self.signal_catched_event.set()
self.missed = True
# then we notify the error
# if the error_code is set to None, we're expecting it to fail.
if error_code != None:
print("An expected signal wasn't received {0!s}".format(error_code))
self.unittest.assertFalse(should_be_caught)
self.watchdog = Watchdog(3, _on_failure)
def __enter__(self):
def __signal_callback(*args):
"""
Difference to SignalCatcher is that we do not skip
the first argument. The first argument by signals is widget
which sends the signal -- we omit this feature when using callbacks
"""
self.signal_arguments.append(args)
if len(self.signal_arguments) >= self.how_many_signals:
self.signal_catched_event.set()
self.handler = self.generator.register_cllbck(self.signal_name, __signal_callback)
self.watchdog.__enter__()
return [self.signal_catched_event, self.signal_arguments]
def __exit__(self, err_type, value, traceback):
self.generator.deregister_cllbck(self.signal_name, self.handler)
if not self.should_be_caught and not hasattr(self, "missed"):
self.assertFalse(True)
return not isinstance(value, Exception) and self.watchdog.__exit__(err_type, value, traceback)
class SignalCatcher(object):
'''
A class to test signals
'''
def __init__(self,
unittest,
generator,
signal_name,
should_be_caught=True,
how_many_signals=1,
error_code="No error code set"):
self.signal_catched_event = threading.Event()
self.generator = generator
self.signal_name = signal_name
self.signal_arguments = []
self.unittest = unittest
self.how_many_signals = how_many_signals
self.should_be_caught = should_be_caught
self.error_code = error_code
def _on_failure():
# we need to release the waiting thread
self.signal_catched_event.set()
self.missed = True
# then we notify the error
# if the error_code is set to None, we're expecting it to fail.
if error_code is not None:
print("An expected signal wasn't received %s" % error_code)
self.unittest.assertFalse(should_be_caught)
self.watchdog = Watchdog(3, _on_failure)
def __enter__(self):
def __signal_callback(*args):
self.signal_arguments.append(args[1:])
if len(self.signal_arguments) >= self.how_many_signals:
self.signal_catched_event.set()
self.handler = self.generator.connect(self.signal_name,
__signal_callback)
self.watchdog.__enter__()
return [self.signal_catched_event, self.signal_arguments]
def __exit__(self, err_type, value, traceback):
self.generator.disconnect(self.handler)
if not self.should_be_caught and not hasattr(self, 'missed'):
self.assertFalse(True)
return (not isinstance(value, Exception)
and self.watchdog.__exit__(err_type, value, traceback))
class SignalCatcher(object):
'''
A class to test signals
'''
def __init__(self, unittest, generator, signal_name,\
should_be_caught = True, how_many_signals = 1, \
error_code = "No error code set"):
self.signal_catched_event = threading.Event()
self.generator = generator
self.signal_name = signal_name
self.signal_arguments = []
self.unittest = unittest
self.how_many_signals = how_many_signals
self.should_be_caught = should_be_caught
self.error_code = error_code
def _on_failure():
#we need to release the waiting thread
self.signal_catched_event.set()
self.missed = True
#then we notify the error
#if the error_code is set to None, we're expecting it to fail.
if error_code != None:
print("An expected signal wasn't received %s" % str(error_code))
self.unittest.assertFalse(should_be_caught)
self.watchdog = Watchdog(3, _on_failure)
def __enter__(self):
def __signal_callback(*args):
self.signal_arguments.append(args[1:])
if len(self.signal_arguments) >= self.how_many_signals:
self.signal_catched_event.set()
self.handler = \
self.generator.connect(self.signal_name, __signal_callback)
self.watchdog.__enter__()
return [self.signal_catched_event, self.signal_arguments]
def __exit__(self, err_type, value, traceback):
self.generator.disconnect(self.handler)
if not self.should_be_caught and not hasattr(self, 'missed'):
self.assertFalse(True)
return not isinstance(value, Exception) and \
self.watchdog.__exit__(err_type, value, traceback)
def __init__(
self,
unittest,
generator,
signal_name,
should_be_caught=True,
how_many_signals=1,
error_code="No error code set",
):
self.signal_catched_event = threading.Event()
self.generator = generator
self.signal_name = signal_name
self.signal_arguments = []
self.unittest = unittest
self.how_many_signals = how_many_signals
self.should_be_caught = should_be_caught
self.error_code = error_code
def _on_failure():
# we need to release the waiting thread
self.signal_catched_event.set()
self.missed = True
# then we notify the error
# if the error_code is set to None, we're expecting it to fail.
if error_code != None:
print("An expected signal wasn't received {0!s}".format(error_code))
self.unittest.assertFalse(should_be_caught)
self.watchdog = Watchdog(3, _on_failure)