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" % str(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 is not 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):
            """ 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 is not 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):
            """ 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 != 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 is not None:
                print("An expected signal wasn't received %s" % str(error_code))
            self.unittest.assertFalse(should_be_caught)

        self.watchdog = Watchdog(3, _on_failure)