From 722bf2b999b39dba0d3df5da591df722d6864279 Mon Sep 17 00:00:00 2001 From: kske Date: Wed, 12 Jan 2022 15:59:45 +0100 Subject: [PATCH] Test priorities for inheritance --- README.md | 5 ++++- .../java/dev/kske/eventbus/core/EventBus.java | 15 +++++++++------ .../dev/kske/eventbus/core/InheritanceTest.java | 8 +++++--- .../eventbus/core/SimpleEventListenerBase.java | 7 ++++++- .../core/SimpleEventListenerInterface.java | 1 + 5 files changed, 25 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 03f8a0d..1ac86e1 100644 --- a/README.md +++ b/README.md @@ -225,7 +225,10 @@ To avoid this, system events never cause system events and instead just issue a 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`. 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 contains an implementation, it is ignored as expected. +If the overridden method already contains an implementation in the superclass, the superclass implementation is ignored as expected. + +The `@Priority` and `@Polymorphic` annotations are inherited both on a class and on a method level. +If the priority or polymorphism has to be redefined on an inherited handler, the `@Event` annotation has to be added explicitly. ## Debugging diff --git a/core/src/main/java/dev/kske/eventbus/core/EventBus.java b/core/src/main/java/dev/kske/eventbus/core/EventBus.java index 7f40551..334dd52 100644 --- a/core/src/main/java/dev/kske/eventbus/core/EventBus.java +++ b/core/src/main/java/dev/kske/eventbus/core/EventBus.java @@ -7,7 +7,6 @@ import java.lang.reflect.*; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Consumer; -import java.util.stream.Collectors; import dev.kske.eventbus.core.handler.*; @@ -272,8 +271,9 @@ public final class EventBus { Set methods = getMethodsAnnotatedWith(listenerClass, Event.class); // Recursively add superclass handlers - if (listenerClass.getSuperclass() != null) - methods.addAll(getHandlerMethods(listenerClass.getSuperclass())); + Class superClass = listenerClass.getSuperclass(); + if (superClass != null && superClass != Object.class) + methods.addAll(getHandlerMethods(superClass)); // Recursively add interface handlers for (Class iClass : listenerClass.getInterfaces()) @@ -292,9 +292,12 @@ public final class EventBus { */ private Set getMethodsAnnotatedWith(Class enclosingClass, Class annotationClass) { - return Arrays.stream(enclosingClass.getDeclaredMethods()) - .filter(m -> m.isAnnotationPresent(annotationClass)) - .collect(Collectors.toSet()); + var methods = new HashSet(); + for (var method : enclosingClass.getDeclaredMethods()) + if (method.isAnnotationPresent(annotationClass)) + methods.add(method); + + return methods; } /** diff --git a/core/src/test/java/dev/kske/eventbus/core/InheritanceTest.java b/core/src/test/java/dev/kske/eventbus/core/InheritanceTest.java index 95c9eac..b72438d 100644 --- a/core/src/test/java/dev/kske/eventbus/core/InheritanceTest.java +++ b/core/src/test/java/dev/kske/eventbus/core/InheritanceTest.java @@ -5,7 +5,8 @@ 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. + * 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 @@ -20,12 +21,12 @@ class InheritanceTest extends SimpleEventListenerBase implements SimpleEventList var event = new SimpleEvent(); bus.dispatch(event); - assertSame(4, event.getCounter()); + assertSame(3, event.getCounter()); } @Override void onSimpleEventAbstractHandler(SimpleEvent event) { - event.increment(); + assertSame(1, event.getCounter()); } @Override @@ -35,6 +36,7 @@ class InheritanceTest extends SimpleEventListenerBase implements SimpleEventList @Event private void onSimpleEventPrivate(SimpleEvent event) { + assertSame(0, event.getCounter()); event.increment(); } } diff --git a/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerBase.java b/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerBase.java index 7ae6de5..1540655 100644 --- a/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerBase.java +++ b/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerBase.java @@ -1,20 +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) { - event.increment(); + fail("This handler should not be invoked"); } + @Priority(150) @Event private void onSimpleEventPrivate(SimpleEvent event) { + assertSame(1, event.getCounter()); event.increment(); } } diff --git a/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerInterface.java b/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerInterface.java index a75e901..8766e34 100644 --- a/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerInterface.java +++ b/core/src/test/java/dev/kske/eventbus/core/SimpleEventListenerInterface.java @@ -8,6 +8,7 @@ package dev.kske.eventbus.core; */ interface SimpleEventListenerInterface { + @Priority(120) @Event void onSimpleEventInterfaceHandler(SimpleEvent event); }