def test_chained_emitters(self):
        """Chained emitters"""
        em1 = EventEmitter(source=None, type='test_event1')
        em2 = EventEmitter(source=self, type='test_event2')
        em1.connect(em2)
        em1.connect(self.record_event)
        self.result = None
        ev = em1()
        self.assert_result(
            event=ev,
            event_class=Event,
            source=None,
            type='test_event1',
            sources=[None])

        # sources look different from second emitter, but type is the same.
        em1.disconnect(self.record_event)
        em2.connect(self.record_event)
        self.result = None
        ev = em1()
        self.assert_result(
            event=ev,
            event_class=Event,
            source=self,
            type='test_event1',
            sources=[
                None,
                self])

 def test_event_kwargs(self):
     """Extra Event kwargs"""
     em = EventEmitter(type='test_event')
     em.default_args['key1'] = 'test1'
     em.connect(self.record_event)
     self.result = None
     em(key2='test2')
     self.assert_result(key1='test1', key2='test2')

 def test_multiple_callbacks(self):
     """Multiple emitter callbacks"""
     em = EventEmitter(type='test_event')
     em.connect(functools.partial(self.record_event, key=1))
     em.connect(functools.partial(self.record_event, key=2))
     em.connect(functools.partial(self.record_event, key=3))
     ev = em()
     self.assert_result(key=1, event=ev, sources=[None])
     self.assert_result(key=2, event=ev, sources=[None])
     self.assert_result(key=3, event=ev, sources=[None])

    def test_prebuilt_event(self):
        """Emit pre-built event"""
        em = EventEmitter(type='test_event')
        em.default_args['key1'] = 'test1'
        em.connect(self.record_event)

        self.result = None
        ev = Event(type='my_type')
        em(ev)
        self.assert_result(event=ev, type='my_type')
        assert not hasattr(self.result[0], 'key1')

 def test_reconnect(self):
     """Ignore callback reconnect"""
     em = EventEmitter(type='test_event')
     def cb(ev):
         self.result += 1
         
     em.connect(cb)
     em.connect(cb)  # second connection should do nothing.
     self.result = 0
     em()
     assert self.result == 1

    def test_emitter_block(self):
        """EventEmitter.blocker"""
        em = EventEmitter(type='test_event')
        em.connect(self.record_event)
        self.result = None

        with em.blocker():
            em()
        assert self.result is None

        ev = em()
        self.assert_result(event=ev)

 def test_event_handling(self):
     """Event.handled"""
     em = EventEmitter(type='test_event')
     def cb1(ev):
         ev.handled = True
     def cb2(ev):
         assert ev.handled
         self.result = 1
     em.connect(cb2)
     em.connect(cb1)
     self.result = None
     em()
     assert self.result == 1

    def test_symbolic_callback(self):
        """Symbolic callbacks"""
        em = EventEmitter(type='test_event')
        em.connect((self, 'record_event'))
        ev = em()
        self.assert_result(event=ev)

        # now check overriding the connected method
        def cb(ev):
            self.result = 1

        self.result = None
        orig_method = self.record_event
        try:
            self.record_event = cb
            em()
            assert self.result == 1
        finally:
            self.record_event = orig_method

    def test_emitter_loop(self):
        """Catch emitter loops"""
        em1 = EventEmitter(type='test_event1')
        em2 = EventEmitter(type='test_event2')
        em1.ignore_callback_errors = False
        em2.ignore_callback_errors = False

        # cross-connect emitters; when we emit, an exception should be raised
        # indicating an event loop.
        em1.connect(em2)
        em2.connect(em1)
        try:
            em1()
        except RuntimeError as err:
            if str(err) != 'EventEmitter loop detected!':
                raise err

 def test_event_block(self):
     """Event.blocked"""
     em = EventEmitter(type='test_event')
     def cb1(ev):
         ev.handled = True
         self.result = 1
     def cb2(ev):
         ev.blocked = True
         self.result = 2
         
     em.connect(self.record_event)
     em.connect(cb1)
     self.result = None
     em()
     self.assert_result()
     
     em.connect(cb2)
     self.result = None
     em()
     assert self.result == 2

    def test_emission_order(self):
        """Event emission order"""
        em = EventEmitter(type='test_event')
        def cb1(ev):
            self.result = 1
        def cb2(ev):
            self.result = 2
            
        em.connect(cb1)
        em.connect(cb2)
        self.result = None
        em()
        assert self.result == 1, "Events emitted in wrong order"

        em.disconnect()
        em.connect(cb2)
        em.connect(cb1)
        self.result = None
        em()
        assert self.result == 2, "Events emitted in wrong order"

 def test_source_stack_integrity(self):
     """Emitter checks source stack"""
     em = EventEmitter(type='test_event')
     
     def cb(ev):
         ev._sources.append('x')
     em.connect(cb)
     
     try:
         em()
     except RuntimeError as err:
         if str(err) != 'Event source-stack mismatch.':
             raise
         
     em.disconnect()
     def cb(ev):
         ev._sources = []
     em.connect(cb)
     
     try:
         em()
     except IndexError:
         pass

 def test_emitter_error_handling(self):
     """Emitter error handling"""
     em = EventEmitter(type='test_event')
     em.print_callback_errors = False
     def cb(ev):
         raise Exception('test')
     
     # first callback fails; second callback still runs.
     em.connect(self.record_event)
     em.connect(cb)
     self.result = None
     ev = em()
     self.assert_result(event=ev)
     
     # this time we should get an exception
     self.result = None
     em.ignore_callback_errors = False
     try:
         em()
         assert False, "Emission should have raised exception"
     except Exception as err:
         if str(err) != 'test':
             raise

def test_event_connect_order():
    """Test event connection order"""
    def a():
        return

    def b():
        return

    def c():
        return

    def d():
        return

    def e():
        return

    def f():
        return

    em = EventEmitter(type='test_event')
    assert_raises(ValueError, em.connect, c, before=['c', 'foo'])
    assert_raises(ValueError, em.connect, c, position='foo')
    assert_raises(TypeError, em.connect, c, ref=dict())
    em.connect(c, ref=True)
    assert_equal((c,), tuple(em.callbacks))
    em.connect(c)
    assert_equal((c,), tuple(em.callbacks))
    em.connect(d, ref=True, position='last')
    assert_equal((c, d), tuple(em.callbacks))
    em.connect(b, ref=True)  # position='first'
    assert_equal((b, c, d), tuple(em.callbacks))
    assert_raises(RuntimeError, em.connect, a, before='c', after='d')  # can't
    em.connect(a, ref=True, before=['c', 'd'])  # first possible pos == 0
    assert_equal((a, b, c, d), tuple(em.callbacks))
    em.connect(f, ref=True, after=['c', 'd'])
    assert_equal((a, b, c, d, f), tuple(em.callbacks))
    em.connect(e, ref=True, after='d', before='f')
    assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs))
    em.disconnect(e)
    em.connect(e, ref=True, after='a', before='f', position='last')
    assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs))
    em.disconnect(e)
    em.connect(e, ref='e', after='d', before='f', position='last')
    assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs))
    em.disconnect(e)
    em.connect(e, after='d', before='f', position='first')  # no name
    assert_equal(('a', 'b', 'c', 'd', None, 'f'), tuple(em.callback_refs))
    em.disconnect(e)
    assert_raises(ValueError, em.connect, e, ref='d')  # duplicate name
    em.connect(e, ref=True, after=[], before='f', position='last')
    assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs))
    assert_equal((a, b, c, d, e, f), tuple(em.callbacks))

    old_e = e

    def e():
        return

    assert_raises(ValueError, em.connect, e, ref=True)  # duplicate name
    em.connect(e)
    assert_equal((None, 'a', 'b', 'c', 'd', 'e', 'f'),
                 tuple(em.callback_refs))
    assert_equal((e, a, b, c, d, old_e, f), tuple(em.callbacks))

    def test_disconnect(self):
        """Emitter disconnection"""
        em = EventEmitter(type='test_event')

        def cb1(ev):
            self.result = 1

        def cb2(ev):
            self.result = 2

        em.connect((self, 'record_event'))
        em.connect(cb1)
        em.connect(cb2)
        self.result = None
        em.disconnect(cb2)
        em.disconnect(cb2)  # should pass silently
        ev = em()
        self.assert_result(event=ev)

        self.result = None
        em.disconnect((self, 'record_event'))
        ev = em()
        assert self.result == 1

        self.result = None
        em.connect(cb1)
        em.connect(cb2)
        em.connect((self, 'record_event'))
        em.disconnect()
        em()
        assert self.result is None