/** Creates a {@code Subscriber} for {@code method} on {@code listener}. */ static Subscriber create(EventBus bus, Object listener, Method method) { return isDeclaredThreadSafe(method) ? new Subscriber(bus, listener, method) : new SynchronizedSubscriber(bus, listener, method); }
/** * Creates a new AsyncEventBus that will use {@code executor} to dispatch events. * * @param executor Executor to use to dispatch events. It is the caller's responsibility to shut * down the executor after the last event has been posted to this event bus. */ public AsyncEventBus(Executor executor) { super("default", executor, Dispatcher.legacyAsync(), LoggingHandler.INSTANCE); } }
/** * Registers all subscriber methods on {@code object} to receive events. * * @param object object whose subscriber methods should be registered. */ public void register(Object object) { subscribers.register(object); }
public void testDeadEventPosting() { GhostCatcher catcher = new GhostCatcher(); bus.register(catcher); bus.post(new DeadEvent(this, EVENT)); List<DeadEvent> events = catcher.getEvents(); assertEquals("The explicit DeadEvent should be delivered.", 1, events.size()); assertEquals("The dead event must not be re-wrapped.", EVENT, events.get(0).getEvent()); }
public void testEventOrderingIsPredictable() { EventProcessor processor = new EventProcessor(); bus.register(processor); EventRecorder recorder = new EventRecorder(); bus.register(recorder); bus.post(FIRST); assertEquals( "EventRecorder expected events in order", Lists.<Object>newArrayList(FIRST, SECOND), recorder.eventsReceived); }
public void testNoReentrantEvents() { ReentrantEventsHater hater = new ReentrantEventsHater(); bus.register(hater); bus.post(FIRST); assertEquals( "ReentrantEventHater expected 2 events", Lists.<Object>newArrayList(FIRST, SECOND), hater.eventsReceived); }
public void testBasicCatcherDistribution() { StringCatcher catcher = new StringCatcher(); bus.register(catcher); bus.post(EVENT); List<String> events = catcher.getEvents(); assertEquals("Only one event should be delivered.", 1, events.size()); assertEquals("Correct string should be delivered.", EVENT, events.get(0)); }
@Subscribe @AllowConcurrentEvents public void threadSafeMethod(Object arg) {}
/** * Records the provided object in {@link #methodArgument} and sets {@link #methodCalled}. This * method is called reflectively by Subscriber during tests, and must remain public. * * @param arg argument to record. */ @Subscribe public void recordingMethod(Object arg) { assertFalse(methodCalled); methodCalled = true; methodArgument = arg; }
@Subscribe public void exceptionThrowingMethod(Object arg) throws Exception { throw new IntentionalException(); }
@Subscribe public void errorThrowingMethod(Object arg) { throw new JudgmentError(); }
public void testToString() throws Exception { EventBus eventBus = new EventBus("a b ; - \" < > / \\ €"); assertEquals("EventBus{a b ; - \" < > / \\ €}", eventBus.toString()); }
public void testUnregister() { StringSubscriber s1 = new StringSubscriber(); StringSubscriber s2 = new StringSubscriber(); registry.register(s1); registry.register(s2); registry.unregister(s1); assertEquals(1, registry.getSubscribersForTesting(String.class).size()); registry.unregister(s2); assertTrue(registry.getSubscribersForTesting(String.class).isEmpty()); }
public void testInvokeSubscriberMethod_basicMethodCall() throws Throwable { Method method = getTestSubscriberMethod("recordingMethod"); Subscriber subscriber = Subscriber.create(bus, this, method); subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT); assertTrue("Subscriber must call provided method", methodCalled); assertTrue( "Subscriber argument must be exactly the provided object.", methodArgument == FIXTURE_ARGUMENT); }
public void testInvokeSubscriberMethod_errorPassthrough() throws Throwable { Method method = getTestSubscriberMethod("errorThrowingMethod"); Subscriber subscriber = Subscriber.create(bus, this, method); try { subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT); fail("Subscribers whose methods throw Errors must rethrow them"); } catch (JudgmentError expected) { } }
public void testRegister() { assertEquals(0, registry.getSubscribersForTesting(String.class).size()); registry.register(new StringSubscriber()); assertEquals(1, registry.getSubscribersForTesting(String.class).size()); registry.register(new StringSubscriber()); assertEquals(2, registry.getSubscribersForTesting(String.class).size()); registry.register(new ObjectSubscriber()); assertEquals(2, registry.getSubscribersForTesting(String.class).size()); assertEquals(1, registry.getSubscribersForTesting(Object.class).size()); }
public PackageSanityTests() throws Exception { DummySubscriber dummySubscriber = new DummySubscriber(); setDefault(Subscriber.class, dummySubscriber.toSubscriber()); setDefault(Method.class, DummySubscriber.subscriberMethod()); setDefault(SubscriberExceptionContext.class, dummySubscriber.toContext()); setDefault(Dispatcher.class, Dispatcher.immediate()); }
Subscriber toSubscriber() throws Exception { return Subscriber.create(eventBus, this, subscriberMethod()); }
public void testDeadEventForwarding() { GhostCatcher catcher = new GhostCatcher(); bus.register(catcher); // A String -- an event for which noone has registered. bus.post(EVENT); List<DeadEvent> events = catcher.getEvents(); assertEquals("One dead event should be delivered.", 1, events.size()); assertEquals("The dead event should wrap the original event.", EVENT, events.get(0).getEvent()); }