Merge pull request #52 from Nordstrom/pr/fix-more-generics

Pr/fix more generics

Author: sbabcoc

README.md

@@ -42,7 +42,7 @@ import com.nordstrom.automation.junit.TestClassWatcher;
 import org.junit.runners.model.FrameworkMethod;
 import org.junit.runners.model.TestClass;
 
-public class ExploringWatcher implements TestClassWatcher, MethodWatcher {
+public class ExploringWatcher implements TestClassWatcher, MethodWatcher<FrameworkMethod> {
 
     ...
 
@@ -58,21 +58,23 @@ public class ExploringWatcher implements TestClassWatcher, MethodWatcher {
     }
 
     @Override
-    public void beforeInvocation(Object runner, Object target, FrameworkMethod method, Object... params) {
+    public void beforeInvocation(Object runner, FrameworkMethod method, ReflectiveCallable callable) {
+        Object target = LifecycleHooks.getFieldValue(callable, "val$target");
         // if target defined
         if (target != null) {
             // get the test class of the runner
             TestClass testClass = LifecycleHooks.getTestClassOf(runner);
+            ...
         }
         ...
     }
 
     @Override
-    public void afterInvocation(Object runner, Object target, FrameworkMethod method, Throwable thrown) {
-        // if target defined
-        if (target != null) {
+    public void afterInvocation(Object runner, FrameworkMethod method, ReflectiveCallable callable, Throwable thrown) {
+        // if child is a 'before' configuration method
+        if (null != method.getAnnotation(Before.class)) {
             // get the atomic test of the runner
-            AtomicTest atomicTest = LifecycleHooks.getAtomicTestOf(runner);
+            AtomicTest<FrameworkMethod> atomicTest = LifecycleHooks.getAtomicTestOf(runner);
             // get the "identity" method
             FrameworkMethod identity = atomicTest.getIdentity();
             ...
@@ -97,10 +99,16 @@ Note that some associations are not available for specific context:
 
 **JUnit Foundation** provides several static utility methods that can be useful in your service provider implementation.
 
+* `LifecycleHooks.isParticleMethod(Object child)`  
+Determines if the specified child is a test or configuration method.
+* `LifecycleHooks.getAnnotation(Object object, Class<T> annotationType)`  
+Returns the annotation of the specified type if the object is tagged with such an annotation.
 * `LifecycleHooks.describeChild(Object target, Object child)`  
 Get a `Description` for the indicated child object from the runner for the specified test class instance.
 * `LifecycleHooks.getInstanceClass(Object instance)`  
 Get class of specified test class instance.
+* `LifecycleHooks.getFieldValue(Object target, String name)`  
+Get the value of the specified field from the supplied object.
 
 ### How to Enable Notifications
 
@@ -124,7 +132,7 @@ The hooks that enable **JUnit Foundation** test lifecycle notifications are inst
     <dependency>
       <groupId>com.nordstrom.tools</groupId>
       <artifactId>junit-foundation</artifactId>
-      <version>9.4.3</version>
+      <version>11.0.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
@@ -201,7 +209,7 @@ repositories {
 }
 dependencies {
     ...
-    compile 'com.nordstrom.tools:junit-foundation:9.4.3
+    compile 'com.nordstrom.tools:junit-foundation:11.0.0
     '
 }
 ext {
@@ -276,12 +284,12 @@ import org.junit.runners.model.FrameworkMethod;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class LoggingWatcher implements MethodWatcher {
+public class LoggingWatcher implements MethodWatcher<FrameworkMethod> {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(LoggingWatcher.class);
 
     @Override
-    public void beforeInvocation(Object target, FrameworkMethod method, Object... params) {
+    public void beforeInvocation(Object runner, FrameworkMethod method, ReflectiveCallable callable) {
         if (null != method.getAnnotation(Test.class)) {
             LOGGER.info(">>>>> ENTER 'test' method {}", method.getName());
         } else if (null != method.getAnnotation(Before.class)) {
@@ -296,7 +304,7 @@ public class LoggingWatcher implements MethodWatcher {
     }
 
     @Override
-    public void afterInvocation(Object obj, FrameworkMethod method, Object... params) {
+    public void afterInvocation(Object runner, FrameworkMethod method, ReflectiveCallable callable, Throwable thrown) {
         if (null != method.getAnnotation(Test.class)) {
             LOGGER.info("<<<<< LEAVE 'test' method {}", method.getName());
         } else if (null != method.getAnnotation(Before.class)) {
@@ -321,6 +329,15 @@ As indicated previously, **JUnit Foundation** will automatically attach standard
 
 **JUnit Foundation** uses this feature internally; notifications sent to **`RunWatcher`** service providers are published by an auto-attached **`RunListener`**. This notification-enhancing run listener, named [RunAnnouncer](https://github.com/Nordstrom/JUnit-Foundation/blob/master/src/main/java/com/nordstrom/automation/junit/RunAnnouncer.java), is registered via the aforementioned [**ServiceLoader** provider configuration file](https://github.com/Nordstrom/JUnit-Foundation/blob/master/src/main/resources/META-INF/services/org.junit.runner.notification.RunListener).
 
+### Getting Attached Watchers and Listeners
+
+**JUnit Foundation** attaches service providers that handle published event notifications via the standard **ServiceLoader** facility. You can acquire references to these service providers through the following methods:
+
+* `LifecycleHooks.getAttachedWatcher(Class<T> watcherType)`  
+Get reference to an instance of the specified watcher type.
+* `LifecycleHooks.getAttachedListener(Class<T> listenerType)`  
+Get reference to an instance of the specified listener type.
+
 ### Support for Parallel Execution
 
 The ability to run **JUnit** tests in parallel is provided by the JUnit 4 test runner of the [Maven Surefire plugin](https://maven.apache.org/surefire/maven-surefire-plugin/examples/fork-options-and-parallel-execution.html). This feature utilizes private **JUnit** interfaces and undocuments behaviors, which greatly complicated the task of adding event notification hooks. As of version [9.0.3](https://github.com/Nordstrom/JUnit-Foundation/releases/tag/junit-foundation-9.0.3), **JUnit Foundation** supports parallel execution of both classes and methods.

pom.xml

@@ -2,7 +2,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.nordstrom.tools</groupId>
   <artifactId>junit-foundation</artifactId>
-  <version>10.0.1-SNAPSHOT</version>
+  <version>11.0.0-SNAPSHOT</version>
   <packaging>jar</packaging>
 
   <name>JUnit Foundation</name>

src/main/java/com/nordstrom/automation/junit/LifecycleHooks.java

@@ -302,28 +302,12 @@ static Field getDeclaredField(Object target, String name) throws NoSuchFieldExce
      * @throws SecurityException if the request is denied
      */
     @SuppressWarnings("unchecked")
-    static <T> T getFieldValue(Object target, String name) throws IllegalAccessException, NoSuchFieldException, SecurityException {
+    public static <T> T getFieldValue(Object target, String name) throws IllegalAccessException, NoSuchFieldException, SecurityException {
         Field field = getDeclaredField(target, name);
         field.setAccessible(true);
         return (T) field.get(target);
     }
 
-    /**
-     * Set the value of the specified field of the supplied object.
-     * 
-     * @param target target object
-     * @param name field name
-     * @param value value to set in the specified field of the supplied object
-     * @throws IllegalAccessException if the {@code Field} object is enforcing access control for an inaccessible field
-     * @throws NoSuchFieldException if a field with the specified name is not found
-     * @throws SecurityException if the request is denied
-     */
-    static void setFieldValue(Object target, String name, Object value) throws IllegalAccessException, NoSuchFieldException, SecurityException {
-        Field field = getDeclaredField(target, name);
-        field.setAccessible(true);
-        field.set(target, value);
-    }
-    
     /**
      * Invoke an intercepted method through its callable proxy.
      * <p>

src/main/java/com/nordstrom/automation/junit/MethodWatcher.java

@@ -1,29 +1,28 @@
 package com.nordstrom.automation.junit;
 
-import org.junit.runners.model.FrameworkMethod;
+import org.junit.internal.runners.model.ReflectiveCallable;
 
 /**
  * This interface defines the methods implemented by JUnit method watchers.
  */
-public interface MethodWatcher extends JUnitWatcher {
+public interface MethodWatcher<T> extends TypeDiscloser<T>, JUnitWatcher {
 
     /**
-     * Invoked before each test or configuration method is invoked
+     * Invoked before each test or configuration method is invoked.
      * 
      * @param runner JUnit test runner
-     * @param target "enhanced" object upon which the method was invoked
-     * @param method {@link FrameworkMethod} object for the invoked method
-     * @param params method invocation parameters
+     * @param child child object of {@code runner} that is being invoked
+     * @param callable {@link ReflectiveCallable} object being intercepted
      */
-    void beforeInvocation(Object runner, Object target, FrameworkMethod method, Object... params);
+    void beforeInvocation(Object runner, T child, ReflectiveCallable callable);
 
     /**
-     * Invoked after each test or configuration method is invoked
+     * Invoked after each test or configuration method is invoked.
      * 
      * @param runner JUnit test runner
-     * @param target "enhanced" object upon which the method was invoked
-     * @param method {@link FrameworkMethod} object for the invoked method
+     * @param child child object of {@code runner} that was just invoked
+     * @param callable {@link ReflectiveCallable} object being intercepted
      * @param thrown exception thrown by method; {@code null} on normal completion
      */
-    void afterInvocation(Object runner, Object target, FrameworkMethod method, Throwable thrown);
+    void afterInvocation(Object runner, T child, ReflectiveCallable callable, Throwable thrown);
 }

src/main/java/com/nordstrom/automation/junit/RetriedTest.java

@@ -75,7 +75,7 @@ public static Description proxyFor(Description description, Throwable thrown) {
             }
         } catch (NoSuchFieldException | SecurityException e) {
             throw new UnsupportedOperationException("Failed acquiring [" + ANNOTATIONS
-                            + "] field of Executable class", e);
+                            + "] field of test method class", e);
         }
         throw new IllegalArgumentException("Specified method is not a JUnit @Test: " + description);
     }

src/main/java/com/nordstrom/automation/junit/RunAnnouncer.java

@@ -13,7 +13,7 @@
 
 import com.google.common.base.Optional;
 
-public class RunAnnouncer<T> extends RunListener {
+public class RunAnnouncer extends RunListener {
 
     @SuppressWarnings("rawtypes")
     private static final ServiceLoader<RunWatcher> runWatcherLoader;
@@ -28,13 +28,15 @@ public class RunAnnouncer<T> extends RunListener {
      * {@inheritDoc}
      */
     @Override
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public void testStarted(Description description) throws Exception {
         LOGGER.debug("testStarted: {}", description);
-        AtomicTest<T> atomicTest = getAtomicTestOf(description);
+        AtomicTest<?> atomicTest = getAtomicTestOf(description);
         synchronized(runWatcherLoader) {
-            for (RunWatcher<T> watcher : runWatcherLoader) {
-                watcher.testStarted(atomicTest);
+            for (RunWatcher watcher : runWatcherLoader) {
+                if (isSupported(watcher, atomicTest)) {
+                    watcher.testStarted(atomicTest);
+                }
             }
         }
     }
@@ -43,13 +45,15 @@ public void testStarted(Description description) throws Exception {
      * {@inheritDoc}
      */
     @Override
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public void testFinished(Description description) throws Exception {
         LOGGER.debug("testFinished: {}", description);
-        AtomicTest<T> atomicTest = getAtomicTestOf(description);
+        AtomicTest<?> atomicTest = getAtomicTestOf(description);
         synchronized(runWatcherLoader) {
-            for (RunWatcher<T> watcher : runWatcherLoader) {
-                watcher.testFinished(atomicTest);
+            for (RunWatcher watcher : runWatcherLoader) {
+                if (isSupported(watcher, atomicTest)) {
+                    watcher.testFinished(atomicTest);
+                }
             }
         }
     }
@@ -58,13 +62,15 @@ public void testFinished(Description description) throws Exception {
      * {@inheritDoc}
      */
     @Override
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public void testFailure(Failure failure) throws Exception {
         LOGGER.debug("testFailure: {}", failure);
-        AtomicTest<T> atomicTest = setTestFailure(failure);
+        AtomicTest<?> atomicTest = setTestFailure(failure);
         synchronized(runWatcherLoader) {
-            for (RunWatcher<T> watcher : runWatcherLoader) {
-                watcher.testFailure(atomicTest, failure.getException());
+            for (RunWatcher watcher : runWatcherLoader) {
+                if (isSupported(watcher, atomicTest)) {
+                    watcher.testFailure(atomicTest, failure.getException());
+                }
             }
         }
     }
@@ -73,13 +79,15 @@ public void testFailure(Failure failure) throws Exception {
      * {@inheritDoc}
      */
     @Override
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public void testAssumptionFailure(Failure failure) {
         LOGGER.debug("testAssumptionFailure: {}", failure);
-        AtomicTest<T> atomicTest = setTestFailure(failure);
+        AtomicTest<?> atomicTest = setTestFailure(failure);
         synchronized(runWatcherLoader) {
-            for (RunWatcher<T> watcher : runWatcherLoader) {
-                watcher.testAssumptionFailure(atomicTest, (AssumptionViolatedException) failure.getException());
+            for (RunWatcher watcher : runWatcherLoader) {
+                if (isSupported(watcher, atomicTest)) {
+                    watcher.testAssumptionFailure(atomicTest, (AssumptionViolatedException) failure.getException());
+                }
             }
         }
     }
@@ -88,13 +96,15 @@ public void testAssumptionFailure(Failure failure) {
      * {@inheritDoc}
      */
     @Override
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public void testIgnored(Description description) throws Exception {
         LOGGER.debug("testIgnored: {}", description);
-        AtomicTest<T> atomicTest = getAtomicTestOf(description);
+        AtomicTest<?> atomicTest = getAtomicTestOf(description);
         synchronized(runWatcherLoader) {
-            for (RunWatcher<T> watcher : runWatcherLoader) {
-                watcher.testIgnored(atomicTest);
+            for (RunWatcher watcher : runWatcherLoader) {
+                if (isSupported(watcher, atomicTest)) {
+                    watcher.testIgnored(atomicTest);
+                }
             }
         }
     }
@@ -117,6 +127,7 @@ static <T> AtomicTest<T> newAtomicTest(Object runner, T identity) {
     /**
      * Get the atomic test object for the specified class runner or method description.
      * 
+     * @param <T> atomic test child object type
      * @param testKey JUnit class runner or method description
      * @return {@link AtomicTest} object (may be {@code null})
      */
@@ -128,6 +139,7 @@ static <T> AtomicTest<T> getAtomicTestOf(Object testKey) {
     /**
      * Store the specified failure in the active atomic test.
      * 
+     * @param <T> atomic test child object type
      * @param failure {@link Failure} object
      * @return {@link AtomicTest} object
      */
@@ -137,6 +149,17 @@ private static <T> AtomicTest<T> setTestFailure(Failure failure) {
         return atomicTest;
     }
 
+    /**
+     * Determine if the run watcher in question supports the specified atomic test.
+     * 
+     * @param watcher {@link RunWatcher} object
+     * @param atomicTest {@link AtomicTest} object
+     * @return {@code true} if the run watcher in question supports the specified atomic test; otherwise {@code false}
+     */
+    private static boolean isSupported(RunWatcher<?> watcher, AtomicTest<?> atomicTest) {
+        return watcher.supportedType().isInstance(atomicTest.getIdentity());
+    }
+    
     /**
      * Get reference to an instance of the specified watcher type.
      *