Merge pull request 'Handler Caching' (#37) from f/handler-caching into develop

Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/37
Reviewed-by: delvh <leon@kske.dev>

Jenkinsfile

@@ -0,0 +1,41 @@
+pipeline {
+	agent any
+
+	options {
+		ansiColor('xterm')
+	}
+
+	stages {
+		stage('Build') {
+			steps {
+				sh 'mvn -DskipTests clean package'
+			}
+		}
+		stage('Test') {
+			steps {
+				sh 'mvn test'
+			}
+			post {
+				always {
+					junit '*/target/surefire-reports/*.xml'
+					publishCoverage adapters: [jacocoAdapter(mergeToOneReport: true, path: '*/target/site/jacoco/jacoco.xml')]
+				}
+			}
+		}
+		stage('SonarQube Analysis') {
+			when {
+				branch 'develop'
+			}
+			steps {
+				withSonarQubeEnv('KSKE SonarQube') {
+					sh 'mvn sonar:sonar'
+				}
+			}
+		}
+	}
+	post {
+		success {
+			archiveArtifacts artifacts: '*/target/event-bus-*.jar'
+		}
+	}
+}

README.md

@@ -54,6 +54,33 @@ private static void onSimpleEvent(SimpleEvent event) { ... }
 
 is technically possible, however you would still have to create an instance of the event listener to register it at an event bus.
 
+## Installation
+
+Event Bus is available in Maven Central.
+To include it inside your project, just add the following dependency to your `pom.xml`:
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>dev.kske</groupId>
+        <artifactId>event-bus-core</artifactId>
+        <version>1.2.0</version>
+    </dependency>
+</dependencies>
+```
+
+Then, require the Event Bus Core module in your `module-info.java`:
+
+```java
+requires dev.kske.eventbus.core;
+```
+
+If you intend to use event handlers that are inaccessible to Event Bus by means of Java language access control, make sure to allow reflective access to your package for Event Bus:
+
+```java
+opens my.package to dev.kske.eventbus.core;
+```
+
 ## Polymorphic Event Handlers
 
 On certain occasions it's practical for an event handler to accept both events of the specified type, as well as subclasses of that event.
@@ -94,6 +121,18 @@ private void onSimpleEvent() {
 
 Make sure that you **do not** both declare a parameter and specify the event type in the annotation, as this would be ambiguous.
 
+## Callback listeners
+
+While defining event handlers as annotated methods is rather simple and readable, sometimes a more flexible approach is required.
+For this reason, there are callback event handlers that allow the registration of an "inline" event listener consisting of just one handler in the form of a consumer:
+
+```java
+EventBus.getInstance().registerListener(SimpleEvent.class, e -> System.out.println("Received " + e));
+```
+
+The event type has to be defined explicitly, with the priority and polymorphism parameters being optional.
+If you intend to remove the listener later, remember to keep a reference to it, as you would have to clear the entire event bus if you didn't.
+
 ## Listener-Level Properties
 
 When defining a dedicated event listener that, for example, performs pre- or post-processing, all event handlers will probably have the same non-standard priority.
@@ -144,14 +183,37 @@ private void onDeadEvent(DeadEvent deadEvent) { ... }
 ### Detecting Exceptions Thrown by Event Handlers
 
 When an event handler throws an exception, an exception event is dispatched that wraps the original event.
-A exception handler is declared as follows:
+An exception handler is declared as follows:
 
 ```java
 private void onExceptionEvent(ExceptionEvent ExceptionEvent) { ... }
 ```
-
 Both system events reference the event bus that caused them and a warning is logged if they are unhandled.
 
+#### Yeeting Exceptions Out of an Event Handler
+
+In some cases, a warning about an `Exception` that was thrown in an event handler is not enough, stays unnoticed, or an exception should be catched explicitly.
+Event Bus explicitly dispatches no `ExceptionEvent` when an `ExceptionWrapper` exception is thrown and instead simply rethrows it.
+`ExceptionWrapper` is an unchecked exception that (as the name says) simply wraps an exception that caused it.
+This means the following is possible and results in a normal program exit:
+```java
+@Event(String.class)
+void onString() {
+	throw new ExceptionWrapper(new RuntimeException("I failed!"));
+}
+
+void helloStackTrace() {
+	EventBus.getInstance().registerListener(this);
+	try {
+		EventBus.getInstance().dispatch("A string!");
+		System.exit(-1);
+	} catch(ExceptionWrapper e) {
+		e.getCause().printStackTrace();
+		System.exit(0);
+	}
+}
+```
+
 ### What About Endless Recursion Caused By Dead Events and Exception Events?
 
 As one might imagine, an unhandled dead event would theoretically lead to an endless recursion.
@@ -159,32 +221,25 @@ The same applies when an exception event handler throws an exception.
 
 To avoid this, system events never cause system events and instead just issue a warning to the logger.
 
-## Installation
+## Inheritance
 
-Event Bus is available in Maven Central.
+When a superclass or an interface of an event listener defines event handlers, they will be detected and registered by Event Bus, even if they are `private`.
-To include it inside your project, just add the following dependency to your `pom.xml`:
+If an event handler is overridden by the listener, the `@Event` annotation of the overridden method is automatically considered present on the overriding method.
+If the overridden method already contains an implementation in the superclass, the superclass implementation is ignored as expected.
 
-```xml
+The `@Priority` and `@Polymorphic` annotations are inherited both on a class and on a method level.
-<dependencies>
+If the priority or polymorphism has to be redefined on an inherited handler, the `@Event` annotation has to be added explicitly.
-    <dependency>
-        <groupId>dev.kske</groupId>
-        <artifactId>event-bus-core</artifactId>
-        <version>1.1.0</version>
-    </dependency>
-</dependencies>
-```
 
-Then, require the Event Bus Core module in your `module-info.java`:
+## Debugging
+
+In more complex setups, taking a look at the event handler execution order can be helpful for debugging.
+Event Bus offers a method for this purpose which can be used as follows:
 
 ```java
-requires dev.kske.eventbus.core;
+System.out.println(EventBus.getInstance().debugExecutionOrder(SimpleEvent.class));
 ```
 
-If you intend to use event handlers that are inaccessible to Event Bus by means of Java language access control, make sure to allow reflective access from your module:
+Then, the execution order can be inspected in the console.
-
-```java
-opens my.module to dev.kske.eventbus.core;
-```
 
 ## Compile-Time Error Checking with Event Bus Proc
 
@@ -205,7 +260,7 @@ When using Maven, it can be registered using the Maven Compiler Plugin:
             <annotationProcessorPath>
                 <groupId>dev.kske</groupId>
                 <artifactId>event-bus-proc</artifactId>
-                <version>1.1.0</version>
+                <version>1.2.0</version>
             </annotationProcessorPath>
         </annotationProcessorPaths>
     </configuration>

core/pom.xml

@@ -0,0 +1,66 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<artifactId>event-bus-core</artifactId>
+	<name>Event Bus Core</name>
+
+	<parent>
+		<groupId>dev.kske</groupId>
+		<artifactId>event-bus</artifactId>
+		<version>1.2.0</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>5.8.1</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+
+		<!-- Disable resource folder -->
+		<resources />
+
+		<plugins>
+
+			<!-- Run unit tests -->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>3.0.0-M5</version>
+				<configuration>
+					<argLine>
+						${argLine}
+						--add-opens dev.kske.eventbus.core/dev.kske.eventbus.core=ALL-UNNAMED
+						--add-opens dev.kske.eventbus.core/dev.kske.eventbus.core.handler=ALL-UNNAMED
+					</argLine>
+				</configuration>
+			</plugin>
+
+			<!-- Generate coverage report -->
+			<plugin>
+				<groupId>org.jacoco</groupId>
+				<artifactId>jacoco-maven-plugin</artifactId>
+				<version>0.8.7</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>prepare-agent</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>report</id>
+						<phase>test</phase>
+						<goals>
+							<goal>report</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+
+		</plugins>
+	</build>
+</project>

core/src/main/java/dev/kske/eventbus/core/Event.java

@@ -30,13 +30,5 @@ public @interface Event {
 	 * @return the event type accepted by the handler
 	 * @since 1.0.0
 	 */
-	Class<?> value() default USE_PARAMETER.class;
+	Class<?> value() default void.class;
-
-	/**
-	 * Signifies that the event type the handler listens to is determined by the type of its only
-	 * parameter.
-	 *
-	 * @since 0.0.3
-	 */
-	static final class USE_PARAMETER {}
 }

core/src/main/java/dev/kske/eventbus/core/EventBus.java

@@ -2,7 +2,8 @@ package dev.kske.eventbus.core;
 
 import java.lang.System.Logger;
 import java.lang.System.Logger.Level;
-import java.lang.reflect.InvocationTargetException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.*;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
@@ -14,9 +15,8 @@ import dev.kske.eventbus.core.handler.*;
  * <p>
  * A singleton instance of this class can be lazily created and acquired using the
  * {@link EventBus#getInstance()} method.
- * <p>
- * This is a thread-safe implementation.
  *
+ * @implNote This is a thread-safe implementation.
  * @author Kai S. K. Engelbart
  * @since 0.0.1
  * @see Event
@@ -90,6 +90,16 @@ public final class EventBus {
 	 */
 	private final Map<Class<?>, TreeSet<EventHandler>> bindings = new ConcurrentHashMap<>();
 
+	/**
+	 * A cache mapping an event class to all handlers the event should be dispatched to. This
+	 * includes polymorphic handlers that don't reference the event class explicitly. If an event
+	 * class is not contained inside this cache, the {@link #bindings} have to be traversed manually
+	 * in search of applicable handlers.
+	 *
+	 * @since 1.3.0
+	 */
+	private final Map<Class<?>, TreeSet<EventHandler>> bindingCache = new ConcurrentHashMap<>();
+
 	/**
 	 * Stores all registered event listeners (which declare event handlers) and prevents them from
 	 * being garbage collected.
@@ -112,10 +122,11 @@ public final class EventBus {
 	 *
 	 * @param event the event to dispatch
 	 * @throws EventBusException    if an event handler isn't accessible or has an invalid signature
+	 * @throws ExceptionWrapper     if it is thrown by an event handler
 	 * @throws NullPointerException if the specified event is {@code null}
 	 * @since 0.0.1
 	 */
-	public void dispatch(Object event) throws EventBusException {
+	public void dispatch(Object event) {
 		Objects.requireNonNull(event);
 		logger.log(Level.INFO, "Dispatching event {0}", event);
 
@@ -140,6 +151,10 @@ public final class EventBus {
 
 							// Transparently pass error to the caller
 							throw (Error) e.getCause();
+						else if (e.getCause() instanceof ExceptionWrapper)
+
+							// Transparently pass exception wrapper to the caller
+							throw (ExceptionWrapper) e.getCause();
 						else if (event instanceof DeadEvent || event instanceof ExceptionEvent)
 
 							// Warn about system event not being handled
@@ -170,11 +185,15 @@ public final class EventBus {
 	 * Searches for the event handlers bound to an event class. This includes polymorphic handlers
 	 * that are bound to a supertype of the event class.
 	 *
+	 * @implNote If the given event type was requested in the past, the handlers are retrieved from
+	 *           the {@link #bindingCache}. If not, the entire {@link #bindings} are traversed in
+	 *           search of polymorphic handlers compatible with the event type.
 	 * @param eventType the event type to use for the search
 	 * @return a navigable set containing the applicable handlers in descending order of priority
 	 * @since 1.2.0
 	 */
 	private NavigableSet<EventHandler> getHandlersFor(Class<?> eventType) {
+		return bindingCache.computeIfAbsent(eventType, k -> {
 
 			// Get handlers defined for the event class
 			TreeSet<EventHandler> handlers =
@@ -188,6 +207,7 @@ public final class EventBus {
 							handlers.add(handler);
 
 			return handlers;
+		});
 	}
 
 	/**
@@ -214,7 +234,7 @@ public final class EventBus {
 	 * @since 0.0.1
 	 * @see Event
 	 */
-	public void registerListener(Object listener) throws EventBusException {
+	public void registerListener(Object listener) {
 		Objects.requireNonNull(listener);
 		if (registeredListeners.contains(listener))
 			throw new EventBusException(listener + " already registered!");
@@ -232,7 +252,7 @@ public final class EventBus {
 			priority = listener.getClass().getAnnotation(Priority.class).value();
 
 		registeredListeners.add(listener);
-		for (var method : listener.getClass().getDeclaredMethods()) {
+		for (var method : getHandlerMethods(listener.getClass())) {
 			Event annotation = method.getAnnotation(Event.class);
 
 			// Skip methods without annotations
@@ -252,6 +272,49 @@ public final class EventBus {
 				listener.getClass().getName());
 	}
 
+	/**
+	 * Searches for event handling methods declared inside the inheritance hierarchy of an event
+	 * listener.
+	 *
+	 * @param listenerClass the class to inspect
+	 * @return all event handling methods defined for the given listener
+	 * @since 1.3.0
+	 */
+	private Set<Method> getHandlerMethods(Class<?> listenerClass) {
+
+		// Get methods declared by the listener
+		Set<Method> methods = getMethodsAnnotatedWith(listenerClass, Event.class);
+
+		// Recursively add superclass handlers
+		Class<?> superClass = listenerClass.getSuperclass();
+		if (superClass != null && superClass != Object.class)
+			methods.addAll(getHandlerMethods(superClass));
+
+		// Recursively add interface handlers
+		for (Class<?> iClass : listenerClass.getInterfaces())
+			methods.addAll(getHandlerMethods(iClass));
+
+		return methods;
+	}
+
+	/**
+	 * Searches for declared methods with a specific annotation inside a class.
+	 *
+	 * @param enclosingClass  the class to inspect
+	 * @param annotationClass the annotation to look for
+	 * @return all methods matching the search criteria
+	 * @since 1.3.0
+	 */
+	private Set<Method> getMethodsAnnotatedWith(Class<?> enclosingClass,
+		Class<? extends Annotation> annotationClass) {
+		var methods = new HashSet<Method>();
+		for (var method : enclosingClass.getDeclaredMethods())
+			if (method.isAnnotationPresent(annotationClass))
+				methods.add(method);
+
+		return methods;
+	}
+
 	/**
 	 * Registers a callback listener, which is a consumer that is invoked when an event occurs. The
 	 * listener is not polymorphic and has the {@link #DEFAULT_PRIORITY}.
@@ -321,15 +384,28 @@ public final class EventBus {
 	}
 
 	/**
-	 * Inserts a new handler into the {@link #bindings} map.
+	 * Inserts a new handler into the {@link #bindings} map. Additionally, the handler is placed
+	 * inside the {@link #bindingCache} where applicable.
 	 *
 	 * @param handler the handler to bind
 	 * @since 1.2.0
 	 */
 	private void bindHandler(EventHandler handler) {
-		bindings.putIfAbsent(handler.getEventType(), new TreeSet<>(byPriority));
+
+		// Bind handler
 		logger.log(Level.DEBUG, "Binding event handler {0}", handler);
-		bindings.get(handler.getEventType()).add(handler);
+		bindings.computeIfAbsent(handler.getEventType(), k -> new TreeSet<>(byPriority))
+			.add(handler);
+
+		// Insert handler into cache
+		bindingCache.computeIfAbsent(handler.getEventType(), k -> new TreeSet<>(byPriority))
+			.add(handler);
+
+		// Handler is polymorphic => insert where applicable
+		if (handler.isPolymorphic())
+			for (var binding : bindingCache.entrySet())
+				if (binding.getKey().isAssignableFrom(handler.getEventType()))
+					binding.getValue().add(handler);
 	}
 
 	/**
@@ -347,13 +423,25 @@ public final class EventBus {
 			var it = binding.iterator();
 			while (it.hasNext()) {
 				var handler = it.next();
-				if (handler.getListener() == listener) {
+				if (handler.getListener().equals(listener)) {
 					logger.log(Level.DEBUG, "Unbinding event handler {0}", handler);
 					it.remove();
 				}
 			}
 		}
 
+		// Remove bindings from cache
+		for (var binding : bindingCache.values()) {
+			var it = binding.iterator();
+			while (it.hasNext()) {
+				var handler = it.next();
+				if (handler.getListener().equals(listener)) {
+					logger.log(Level.TRACE, "Removing event handler {0} from cache", handler);
+					it.remove();
+				}
+			}
+		}
+
 		// Remove the listener itself
 		registeredListeners.remove(listener);
 	}
@@ -366,6 +454,7 @@ public final class EventBus {
 	public void clearListeners() {
 		logger.log(Level.INFO, "Clearing event listeners");
 		bindings.clear();
+		bindingCache.clear();
 		registeredListeners.clear();
 	}
 
@@ -381,7 +470,7 @@ public final class EventBus {
 	 * @return a human-readable event handler list suitable for debugging purposes
 	 * @since 1.2.0
 	 */
-	public String printExecutionOrder(Class<?> eventType) {
+	public String debugExecutionOrder(Class<?> eventType) {
 		var	handlers	= getHandlersFor(eventType);
 		var	sj			= new StringJoiner("\n");
 

core/src/main/java/dev/kske/eventbus/core/EventBusException.java

@@ -14,13 +14,14 @@ package dev.kske.eventbus.core;
  */
 public final class EventBusException extends RuntimeException {
 
-	private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 7254445250300604449L;
 
 	/**
 	 * Creates a new event bus exception.
 	 *
 	 * @param message the message to display
 	 * @param cause   the cause of this exception
+	 * @since 0.0.1
 	 */
 	public EventBusException(String message, Throwable cause) {
 		super(message, cause);
@@ -30,6 +31,7 @@ public final class EventBusException extends RuntimeException {
 	 * Creates a new event bus exception.
 	 *
 	 * @param message the message to display
+	 * @since 0.0.1
 	 */
 	public EventBusException(String message) {
 		super(message);

core/src/main/java/dev/kske/eventbus/core/ExceptionWrapper.java

@@ -0,0 +1,24 @@
+package dev.kske.eventbus.core;
+
+/**
+ * This unchecked exception acts as a wrapper for an arbitrary exception to prevent an
+ * {@link ExceptionEvent} from being dispatched. Instead, the wrapped exception is rethrown by
+ * {@link EventBus#dispatch(Object)}.
+ *
+ * @author Kai S. K. Engelbart
+ * @since 1.2.1
+ */
+public final class ExceptionWrapper extends RuntimeException {
+
+	private static final long serialVersionUID = -2016681140617308788L;
+
+	/**
+	 * Creates a new exception wrapper.
+	 *
+	 * @param cause the exception to wrap
+	 * @since 1.2.1
+	 */
+	public ExceptionWrapper(Exception cause) {
+		super(cause);
+	}
+}

core/src/main/java/dev/kske/eventbus/core/Polymorphic.java

@@ -18,6 +18,7 @@ import java.lang.annotation.*;
  * @see Event
  */
 @Documented
+@Inherited
 @Retention(RUNTIME)
 @Target({ METHOD, TYPE })
 public @interface Polymorphic {

core/src/main/java/dev/kske/eventbus/core/Priority.java

@@ -21,6 +21,7 @@ import java.lang.annotation.*;
  * @see Event
  */
 @Documented
+@Inherited
 @Retention(RUNTIME)
 @Target({ METHOD, TYPE })
 public @interface Priority {

core/src/main/java/dev/kske/eventbus/core/handler/ReflectiveEventHandler.java

@@ -3,7 +3,6 @@ package dev.kske.eventbus.core.handler;
 import java.lang.reflect.*;
 
 import dev.kske.eventbus.core.*;
-import dev.kske.eventbus.core.Event.USE_PARAMETER;
 
 /**
  * An event handler wrapping a method annotated with {@link Event} and executing it using
@@ -37,7 +36,7 @@ public final class ReflectiveEventHandler implements EventHandler {
 		boolean defPolymorphism, int defPriority) throws EventBusException {
 		this.listener	= listener;
 		this.method		= method;
-		useParameter	= annotation.value() == USE_PARAMETER.class;
+		useParameter	= annotation.value() == void.class;
 
 		// Check handler signature
 		if (method.getParameterCount() == 0 && useParameter)
@@ -58,7 +57,8 @@ public final class ReflectiveEventHandler implements EventHandler {
 			? method.getAnnotation(Priority.class).value()
 			: defPriority;
 
-		// Allow access if the method is non-public
+		// Try to allow access if the method is not accessible
+		if (!method.canAccess(Modifier.isStatic(method.getModifiers()) ? null : listener))
 			method.setAccessible(true);
 	}
 

core/src/test/java/dev/kske/eventbus/core/CancelTest.java

@@ -11,7 +11,7 @@ import org.junit.jupiter.api.*;
  * @author Leon Hofmeister
  * @since 0.1.0
  */
-public class CancelTest {
+class CancelTest {
 
 	EventBus	bus;
 	int			hits;
@@ -22,7 +22,7 @@ public class CancelTest {
 	 * @since 0.1.0
 	 */
 	@BeforeEach
-	public void registerListener() {
+	void registerListener() {
 		bus = new EventBus();
 		bus.registerListener(this);
 	}
@@ -34,7 +34,7 @@ public class CancelTest {
 	 * @since 0.1.0
 	 */
 	@Test
-	public void testCancellation() {
+	void testCancellation() {
 		bus.dispatch(new SimpleEvent());
 		assertEquals(1, hits);
 	}

core/src/test/java/dev/kske/eventbus/core/DeadTest.java

@@ -10,7 +10,7 @@ import org.junit.jupiter.api.Test;
  * @author Kai S. K. Engelbart
  * @since 1.1.0
  */
-public class DeadTest {
+class DeadTest {
 
 	EventBus	bus		= new EventBus();
 	String		event	= "This event has no handler";
@@ -22,7 +22,7 @@ public class DeadTest {
 	 * @since 1.1.0
 	 */
 	@Test
-	public void testDeadEvent() {
+	void testDeadEvent() {
 		bus.registerListener(this);
 		bus.dispatch(event);
 		assertTrue(deadEventHandled);
@@ -36,7 +36,7 @@ public class DeadTest {
 	 * @since 1.1.0
 	 */
 	@Test
-	public void testUnhandledDeadEvent() {
+	void testUnhandledDeadEvent() {
 		bus.dispatch(event);
 	}
 

core/src/test/java/dev/kske/eventbus/core/DispatchTest.java

@@ -12,10 +12,9 @@ import org.junit.jupiter.api.*;
  */
 @Polymorphic
 @Priority(150)
-public class DispatchTest {
+class DispatchTest {
 
 	EventBus bus;
-	static int	hits;
 
 	/**
 	 * Constructs an event bus and registers this test instance as an event listener.
@@ -23,12 +22,12 @@ public class DispatchTest {
 	 * @since 0.0.1
 	 */
 	@BeforeEach
-	public void registerListener() {
+	void registerListener() {
 		bus = new EventBus();
 		bus.registerListener(this);
 		bus.registerListener(SimpleEvent.class, e -> {
-			++hits;
+			e.increment();
-			assertEquals(4, hits);
+			assertEquals(3, e.getCounter());
 		});
 	}
 
@@ -39,41 +38,51 @@ public class DispatchTest {
 	 * @since 0.0.1
 	 */
 	@Test
-	public void testDispatch() {
+	void testDispatch() {
 		bus.dispatch(new SimpleEventSub());
 		bus.dispatch(new SimpleEvent());
 	}
 
 	/**
-	 * Tests {@link EventBus#printExecutionOrder(Class)} based on the currently registered handlers.
+	 * Tests {@link EventBus#debugExecutionOrder(Class)} based on the currently registered handlers.
 	 *
 	 * @since 1.2.0
 	 */
 	@Test
-	public void testPrintExecutionOrder() {
+	void testDebugExecutionOrder() {
-		String executionOrder = bus.printExecutionOrder(SimpleEvent.class);
-		System.out.println(executionOrder);
 		assertEquals(
 			"Event handler execution order for class dev.kske.eventbus.core.SimpleEvent (3 handler(s)):\n"
 				+ "==========================================================================================\n"
-				+ "ReflectiveEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=true, priority=200, method=void dev.kske.eventbus.core.DispatchTest.onSimpleEventFirst(), useParameter=false]\n"
+				+ "ReflectiveEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=true, priority=200, method=void dev.kske.eventbus.core.DispatchTest.onSimpleEventFirst(dev.kske.eventbus.core.SimpleEvent), useParameter=true]\n"
-				+ "ReflectiveEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=false, priority=150, method=static void dev.kske.eventbus.core.DispatchTest.onSimpleEventSecond(), useParameter=false]\n"
+				+ "ReflectiveEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=false, priority=150, method=static void dev.kske.eventbus.core.DispatchTest.onSimpleEventSecond(dev.kske.eventbus.core.SimpleEvent), useParameter=true]\n"
 				+ "CallbackEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=false, priority=100]\n"
 				+ "==========================================================================================",
-			executionOrder);
+			bus.debugExecutionOrder(SimpleEvent.class));
 	}
 
-	@Event(SimpleEvent.class)
+	/**
+	 * Tests whether the handlers bound to an event type are correct when retrieved from the binding
+	 * cache. On the second call of {@link EventBus#debugExecutionOrder(Class)} the cache is used.
+	 *
+	 * @since 1.3.0
+	 */
+	@Test
+	void testBindingCache() {
+		assertEquals(bus.debugExecutionOrder(SimpleEventSub.class),
+			bus.debugExecutionOrder(SimpleEventSub.class));
+	}
+
+	@Event
 	@Priority(200)
-	void onSimpleEventFirst() {
+	void onSimpleEventFirst(SimpleEvent event) {
-		++hits;
+		event.increment();
-		assertTrue(hits == 1 || hits == 2);
+		assertTrue(event.getCounter() == 1 || event.getCounter() == 2);
 	}
 
-	@Event(SimpleEvent.class)
+	@Event
 	@Polymorphic(false)
-	static void onSimpleEventSecond() {
+	static void onSimpleEventSecond(SimpleEvent event) {
-		++hits;
+		event.increment();
-		assertEquals(3, hits);
+		assertEquals(2, event.getCounter());
 	}
 }

core/src/test/java/dev/kske/eventbus/core/ExceptionTest.java

@@ -10,7 +10,7 @@ import org.junit.jupiter.api.Test;
  * @author Kai S. K. Engelbart
  * @since 1.1.0
  */
-public class ExceptionTest {
+class ExceptionTest {
 
 	EventBus			bus			= new EventBus();
 	String				event		= "This event will cause an exception";
@@ -23,7 +23,7 @@ public class ExceptionTest {
 	 * @since 1.1.0
 	 */
 	@Test
-	public void testExceptionEvent() {
+	void testExceptionEvent() {
 		bus.registerListener(this);
 		bus.registerListener(new ExceptionListener());
 		bus.dispatch(event);
@@ -38,7 +38,7 @@ public class ExceptionTest {
 	 * @since 1.1.0
 	 */
 	@Test
-	public void testUnhandledExceptionEvent() {
+	void testUnhandledExceptionEvent() {
 		bus.registerListener(this);
 		bus.dispatch(event);
 		bus.removeListener(this);

core/src/test/java/dev/kske/eventbus/core/ExceptionWrapperTest.java

@@ -0,0 +1,33 @@
+package dev.kske.eventbus.core;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests the behavior of the event bus when an {@link ExceptionWrapper} is thrown.
+ *
+ * @author Kai S. K. Engelbart
+ * @since 1.2.1
+ */
+class ExceptionWrapperTest {
+
+	EventBus	bus		= new EventBus();
+	String		event	= "This event will cause an exception";
+
+	/**
+	 * Tests transparent rethrowing of an exception wrapper by {@link EventBus#dispatch(Object)}.
+	 *
+	 * @since 1.2.1
+	 */
+	@Test
+	void testExceptionWrapper() {
+		bus.registerListener(this);
+		assertThrows(ExceptionWrapper.class, () -> bus.dispatch(event));
+	}
+
+	@Event(String.class)
+	void onString() {
+		throw new ExceptionWrapper(new RuntimeException("I failed!"));
+	}
+}

core/src/test/java/dev/kske/eventbus/core/InheritanceTest.java

@@ -0,0 +1,43 @@
+package dev.kske.eventbus.core;
+
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests whether event handlers correctly work in the context of an inheritance hierarchy. The
+ * effect of handler priorities is also accounted for.
+ *
+ * @author Kai S. K. Engelbart
+ * @since 1.3.0
+ */
+class InheritanceTest extends SimpleEventListenerBase implements SimpleEventListenerInterface {
+
+	EventBus bus = new EventBus();
+
+	@Test
+	void test() {
+		bus.registerListener(this);
+		var event = new SimpleEvent();
+
+		bus.dispatch(event);
+		assertSame(3, event.getCounter());
+	}
+
+	@Override
+	void onSimpleEventAbstractHandler(SimpleEvent event) {
+		assertSame(1, event.getCounter());
+	}
+
+	@Override
+	public void onSimpleEventInterfaceHandler(SimpleEvent event) {
+		event.increment();
+	}
+
+	@Event
+	@Priority(250)
+	private void onSimpleEventPrivate(SimpleEvent event) {
+		assertSame(0, event.getCounter());
+		event.increment();
+	}
+}

core/src/test/java/dev/kske/eventbus/core/NestedTest.java

@@ -10,7 +10,7 @@ import org.junit.jupiter.api.*;
  * @author Kai S. K. Engelbart
  * @since 1.2.0
  */
-public class NestedTest {
+class NestedTest {
 
 	EventBus	bus;
 	boolean		nestedHit;
@@ -21,7 +21,7 @@ public class NestedTest {
 	 * @since 1.2.0
 	 */
 	@BeforeEach
-	public void registerListener() {
+	void registerListener() {
 		bus = new EventBus();
 		bus.registerListener(this);
 	}
@@ -34,7 +34,7 @@ public class NestedTest {
 	 * @since 1.2.0
 	 */
 	@Test
-	public void testNestedDispatch() {
+	void testNestedDispatch() {
 		bus.dispatch(new SimpleEvent());
 		assertTrue(nestedHit);
 	}

core/src/test/java/dev/kske/eventbus/core/SimpleEvent.java

@@ -0,0 +1,31 @@
+package dev.kske.eventbus.core;
+
+/**
+ * A simple event for testing purposes. The event contains a counter that is supposed to be
+ * incremented when the event is processed by a handler. That way it is possible to test whether all
+ * handlers that were supposed to be invoked were in fact invoked.
+ *
+ * @author Kai S. K. Engelbart
+ * @since 0.0.1
+ */
+class SimpleEvent {
+
+	private int counter;
+
+	@Override
+	public String toString() {
+		return String.format("%s[%d]", getClass().getSimpleName(), counter);
+	}
+
+	void increment() {
+		++counter;
+	}
+
+	int getCounter() {
+		return counter;
+	}
+
+	void reset() {
+		counter = 0;
+	}
+}

core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerBase.java

@@ -0,0 +1,25 @@
+package dev.kske.eventbus.core;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * An abstract class defining a package-private and a private handler for {@link SimpleEvent}.
+ *
+ * @author Kai S. K. Engelbart
+ * @since 1.3.0
+ */
+@Priority(200)
+abstract class SimpleEventListenerBase {
+
+	@Event
+	void onSimpleEventAbstractHandler(SimpleEvent event) {
+		fail("This handler should not be invoked");
+	}
+
+	@Event
+	@Priority(150)
+	private void onSimpleEventPrivate(SimpleEvent event) {
+		assertSame(1, event.getCounter());
+		event.increment();
+	}
+}

core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerInterface.java

@@ -0,0 +1,14 @@
+package dev.kske.eventbus.core;
+
+/**
+ * An interface defining a single handler for {@link SimpleEvent}.
+ *
+ * @author Kai S. K. Engelbart
+ * @since 1.3.0
+ */
+interface SimpleEventListenerInterface {
+
+	@Priority(120)
+	@Event
+	void onSimpleEventInterfaceHandler(SimpleEvent event);
+}

core/src/test/java/dev/kske/eventbus/core/SimpleEventSub.java

@@ -6,4 +6,4 @@ package dev.kske.eventbus.core;
  * @author Kai S. K. Engelbart
  * @since 0.0.4
  */
-public class SimpleEventSub extends SimpleEvent {}
+class SimpleEventSub extends SimpleEvent {}

event-bus-core/pom.xml

@@ -1,39 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-
-	<artifactId>event-bus-core</artifactId>
-	<name>Event Bus Core</name>
-
-	<parent>
-		<groupId>dev.kske</groupId>
-		<artifactId>event-bus</artifactId>
-		<version>1.1.0</version>
-	</parent>
-
-	<dependencies>
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
-			<version>5.8.1</version>
-			<scope>test</scope>
-		</dependency>
-	</dependencies>
-
-	<build>
-
-		<!-- Disable resource folder -->
-		<resources />
-
-		<!-- Run unit tests -->
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0-M5</version>
-			</plugin>
-		</plugins>
-
-	</build>
-</project>

event-bus-core/src/test/java/dev/kske/eventbus/core/SimpleEvent.java

@@ -1,9 +0,0 @@
-package dev.kske.eventbus.core;
-
-/**
- * A simple event for testing purposes.
- *
- * @author Kai S. K. Engelbart
- * @since 0.0.1
- */
-public class SimpleEvent {}

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>dev.kske</groupId>
 	<artifactId>event-bus</artifactId>
-	<version>1.1.0</version>
+	<version>1.2.0</version>
 	<packaging>pom</packaging>
 
 	<name>Event Bus</name>
@@ -13,8 +13,8 @@
 	<url>https://git.kske.dev/kske/event-bus</url>
 
 	<modules>
-		<module>event-bus-core</module>
+		<module>core</module>
-		<module>event-bus-proc</module>
+		<module>proc</module>
 	</modules>
 
 	<licenses>

proc/.classpath

@@ -16,17 +16,17 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="home/kske/git/event-bus/event-bus-ap">
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
 		<attributes>
 			<attribute name="optional" value="true"/>
 			<attribute name="maven.pomderived" value="true"/>
 			<attribute name="test" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>

proc/pom.xml

@@ -11,7 +11,7 @@
 	<parent>
 		<groupId>dev.kske</groupId>
 		<artifactId>event-bus</artifactId>
-		<version>1.1.0</version>
+		<version>1.2.0</version>
 	</parent>
 
 	<dependencies>
@@ -24,9 +24,6 @@
 
 	<build>
 
-		<!-- Disable test folder -->
-		<testSourceDirectory />
-
 		<plugins>
 
 			<!-- Prevent annotation processing error during compilation -->

proc/src/main/java/dev/kske/eventbus/proc/EventProcessor.java

@@ -47,13 +47,12 @@ public class EventProcessor extends AbstractProcessor {
 
 				// Task failed successfully
 				eventType		= e.getTypeMirror();
-				useParameter	= processingEnv.getTypeUtils().isSameType(eventType,
+				useParameter	= eventType.getKind() == TypeKind.VOID;
-					getTypeMirror(Event.USE_PARAMETER.class));
 			}
 
 			// Check handler signature
 			boolean pass = false;
-			if (useParameter && eventHandler.getParameters().size() == 0)
+			if (useParameter && eventHandler.getParameters().isEmpty())
 				error(eventHandler, "The method or the annotation must define the event type");
 			else if (!useParameter && eventHandler.getParameters().size() == 1)
 				error(eventHandler,
@@ -107,7 +106,8 @@ public class EventProcessor extends AbstractProcessor {
 				polymorphic = eventHandler.getAnnotation(Polymorphic.class).value();
 
 			// Effective priority
-			int priority = hasListenerPriority ? listenerPriority.value() : defPriority;
+			int		priority			=
+				hasListenerPriority ? listenerPriority.value() : defPriority;
 			boolean	hasHandlerPriority	= eventHandler.getAnnotation(Priority.class) != null;
 			if (hasHandlerPriority)
 				priority = eventHandler.getAnnotation(Priority.class).value();
@@ -137,14 +137,6 @@ public class EventProcessor extends AbstractProcessor {
 		}
 	}
 
-	private TypeMirror getTypeMirror(Class<?> clazz) {
-		return getTypeElement(clazz).asType();
-	}
-
-	private TypeElement getTypeElement(Class<?> clazz) {
-		return processingEnv.getElementUtils().getTypeElement(clazz.getCanonicalName());
-	}
-
 	private void warning(Element e, String msg, Object... args) {
 		processingEnv.getMessager().printMessage(Kind.WARNING, String.format(msg, args), e);
 	}

proc/src/main/java/module-info.java

@@ -5,7 +5,7 @@
  * @author Kai S. K. Engelbart
  * @since 1.0.0
  */
-module dev.kske.eventbus.ap {
+module dev.kske.eventbus.proc {
 
 	requires java.compiler;
 	requires dev.kske.eventbus.core;