Added a unit test for the simple event dispatcher.
diff --git a/core/trivial/src/test/java/org/onlab/onos/event/impl/SimpleEventDispatcherTest.java b/core/trivial/src/test/java/org/onlab/onos/event/impl/SimpleEventDispatcherTest.java
new file mode 100644
index 0000000..88ba165
--- /dev/null
+++ b/core/trivial/src/test/java/org/onlab/onos/event/impl/SimpleEventDispatcherTest.java
@@ -0,0 +1,117 @@
+package org.onlab.onos.event.impl;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.onos.event.AbstractEvent;
+import org.onlab.onos.event.EventSink;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Test of the even dispatcher mechanism.
+ */
+public class SimpleEventDispatcherTest {
+
+ private final SimpleEventDispatcher dispatcher = new SimpleEventDispatcher();
+ private final PrickleSink prickleSink = new PrickleSink();
+ private final GooSink gooSink = new GooSink();
+
+ @Before
+ public void setUp() {
+ dispatcher.activate();
+ dispatcher.addSink(Prickle.class, prickleSink);
+ dispatcher.addSink(Goo.class, gooSink);
+ }
+
+ @After
+ public void tearDown() {
+ dispatcher.removeSink(Goo.class);
+ dispatcher.removeSink(Prickle.class);
+ dispatcher.deactivate();
+ }
+
+ @Test
+ public void post() throws Exception {
+ prickleSink.latch = new CountDownLatch(1);
+ dispatcher.post(new Prickle("yo"));
+ prickleSink.latch.await(100, TimeUnit.MILLISECONDS);
+ validate(prickleSink, "yo");
+ validate(gooSink);
+ }
+
+ @Test
+ public void postEventWithBadSink() throws Exception {
+ gooSink.latch = new CountDownLatch(1);
+ dispatcher.post(new Goo("boom"));
+ gooSink.latch.await(100, TimeUnit.MILLISECONDS);
+ validate(gooSink, "boom");
+ validate(prickleSink);
+ }
+
+ @Test
+ public void postEventWithNoSink() throws Exception {
+ dispatcher.post(new Thing("boom"));
+ validate(gooSink);
+ validate(prickleSink);
+ }
+
+ private void validate(Sink sink, String... strings) {
+ int i = 0;
+ assertEquals("incorrect event count", strings.length, sink.subjects.size());
+ for (String string : strings) {
+ assertEquals("incorrect event", string, sink.subjects.get(i++));
+ }
+ }
+
+ private enum Type { FOO };
+
+ private static class Thing extends AbstractEvent<Type, String> {
+ protected Thing(String subject) {
+ super(Type.FOO, subject);
+ }
+ }
+
+ private static class Prickle extends Thing {
+ protected Prickle(String subject) {
+ super(subject);
+ }
+ }
+
+ private static class Goo extends Thing {
+ protected Goo(String subject) {
+ super(subject);
+ }
+ }
+
+ private static class Sink {
+ final List<String> subjects = new ArrayList<>();
+ CountDownLatch latch;
+
+ protected void process(String subject) {
+ subjects.add(subject);
+ latch.countDown();
+ }
+ }
+
+ private static class PrickleSink extends Sink implements EventSink<Prickle> {
+ @Override
+ public void process(Prickle event) {
+ process(event.subject());
+ }
+ }
+
+ private static class GooSink extends Sink implements EventSink<Goo> {
+ @Override
+ public void process(Goo event) {
+ process(event.subject());
+ throw new IllegalStateException("BOOM!");
+ }
+ }
+
+}