Release framework objects ASAP to minimize memory consumption

Author: sbabcoc

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

@@ -0,0 +1,38 @@
+package com.nordstrom.automation.junit;
+
+import java.util.concurrent.Callable;
+
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.internal.runners.model.EachTestNotifier;
+
+import net.bytebuddy.implementation.bind.annotation.Argument;
+import net.bytebuddy.implementation.bind.annotation.SuperCall;
+import net.bytebuddy.implementation.bind.annotation.This;
+
+/**
+ * This class declares the interceptor for the {@link org.junit.internal.runners.model.EachTestNotifier#addFailure
+ * addFailure} method.
+ */
+public class AddFailure {
+
+    /**
+     * Interceptor for the {@link org.junit.internal.runners.model.EachTestNotifier#addFailure addFailure} method.
+     * 
+     * @param notifier underlying run notifier
+     * @param proxy callable proxy for the intercepted method
+     * @param targetException the exception thrown by the test
+     * @throws Exception {@code anything} (exception thrown by the intercepted method)
+     */
+    public static void intercept(@This final EachTestNotifier notifier, @SuperCall final Callable<?> proxy,
+            @Argument(0) final Throwable targetException) throws Exception {
+        
+        if ( ! (targetException instanceof MultipleFailureException)) {
+            AtomicTest atomicTest = EachTestNotifierInit.getAtomicTestOf(notifier);
+            if (atomicTest != null) {
+                atomicTest.setThrowable(targetException);
+            }
+        }
+        
+        LifecycleHooks.callProxy(proxy);
+    }
+}

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

@@ -20,12 +20,12 @@
  */
 public class ArtifactCollector<T extends ArtifactType> extends AtomIdentity {
 
-    private static final ConcurrentHashMap<Description, List<ArtifactCollector<? extends ArtifactType>>> watcherMap;
-    private static final Function<Description, List<ArtifactCollector<? extends ArtifactType>>> newInstance;
+    private static final ConcurrentHashMap<Description, List<ArtifactCollector<? extends ArtifactType>>> WATCHER_MAP;
+    private static final Function<Description, List<ArtifactCollector<? extends ArtifactType>>> NEW_INSTANCE;
 
     static {
-        watcherMap = new ConcurrentHashMap<>();
-        newInstance = new Function<Description, List<ArtifactCollector<? extends ArtifactType>>>() {
+        WATCHER_MAP = new ConcurrentHashMap<>();
+        NEW_INSTANCE = new Function<Description, List<ArtifactCollector<? extends ArtifactType>>>() {
             @Override
             public List<ArtifactCollector<? extends ArtifactType>> apply(Description input) {
                 return new ArrayList<>();
@@ -48,7 +48,7 @@ public ArtifactCollector(Object instance, T provider) {
     public void starting(Description description) {
         super.starting(description);
         List<ArtifactCollector<? extends ArtifactType>> watcherList =
-                        LifecycleHooks.computeIfAbsent(watcherMap, description, newInstance);
+                        LifecycleHooks.computeIfAbsent(WATCHER_MAP, description, NEW_INSTANCE);
         watcherList.add(this);
     }
 
@@ -189,7 +189,7 @@ public T getArtifactProvider() {
     @SuppressWarnings("unchecked")
     public static <S extends ArtifactCollector<? extends ArtifactType>> Optional<S>
                     getWatcher(Description description, Class<S> watcherType) {
-        List<ArtifactCollector<? extends ArtifactType>> watcherList = watcherMap.get(description);
+        List<ArtifactCollector<? extends ArtifactType>> watcherList = WATCHER_MAP.get(description);
         if (watcherList != null) {
             for (ArtifactCollector<? extends ArtifactType> watcher : watcherList) {
                 if (watcher.getClass() == watcherType) {

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

@@ -2,8 +2,11 @@
 
 import static com.nordstrom.automation.junit.LifecycleHooks.invoke;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.junit.After;
 import org.junit.AfterClass;
@@ -12,6 +15,7 @@
 import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.Description;
+import org.junit.runners.model.FrameworkMethod;
 import org.junit.runners.model.TestClass;
 
 /**
@@ -21,25 +25,20 @@
  */
 @Ignore
 @SuppressWarnings("all")
-public class AtomicTest<T> {
+public class AtomicTest {
     private final Object runner;
     private final Description description;
-    private final T identity;
-    private final List<T> particles;
+    private final FrameworkMethod identity;
+    private final List<FrameworkMethod> particles;
     private Throwable thrown;
-
-    public AtomicTest(Object runner, T identity) {
-        this.runner = runner;
-        this.identity = identity;
-        this.description = invoke(runner, "describeChild", identity);
-        this.particles = invoke(runner, "getChildren");
-    }
 
-    public AtomicTest(AtomicTest<T> original, Description description) {
-        this.runner = original.runner;
-        this.identity = original.identity;
+    private static final Pattern PARAM = Pattern.compile("[(\\[]");
+
+    public AtomicTest(Description description) {
+        this.runner = RunChildren.getThreadRunner();
         this.description = description;
-        this.particles = original.particles;
+        this.particles = getParticles(runner, description);
+        this.identity = this.particles.get(0);
     }
 
     /**
@@ -65,7 +64,7 @@ public Description getDescription() {
      * 
      * @return core method associated with this atomic test
      */
-    public T getIdentity() {
+    public FrameworkMethod getIdentity() {
         return identity;
     }
 
@@ -74,7 +73,7 @@ public T getIdentity() {
      * 
      * @return list of methods that compose this atomic test
      */
-    public List<T> getParticles() {
+    public List<FrameworkMethod> getParticles() {
         return particles;
     }
 
@@ -111,10 +110,24 @@ public Throwable getThrowable() {
      * @param method method object
      * @return {@code true} if this atomic test includes the specified method; otherwise {@code false}
      */
-    public boolean includes(T method) {
+    public boolean includes(FrameworkMethod method) {
         return particles.contains(method);
     }
 
+    /**
+     * Determine if this atomic test represents a "theory" method.
+     * 
+     * @return {@code true} if this atomic test represents a "theory" method; otherwise {@code false}
+     */
+    public boolean isTheory() {
+        try {
+            String uniqueId = LifecycleHooks.getFieldValue(description, "fUniqueId");
+            return ((uniqueId != null) && (uniqueId.startsWith("theory-id: ")));
+        } catch (IllegalAccessException | NoSuchFieldException | SecurityException e) {
+            return false;
+        }
+    }
+    
     /**
      * {@inheritDoc}
      */
@@ -130,7 +143,7 @@ public String toString() {
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        AtomicTest<T> that = (AtomicTest<T>) o;
+        AtomicTest that = (AtomicTest) o;
         return Objects.equals(runner, that.runner) &&
                 Objects.equals(identity, that.identity);
     }
@@ -140,6 +153,44 @@ public boolean equals(Object o) {
      */
     @Override
     public int hashCode() {
-        return Objects.hash(runner, identity);
+        return description.hashCode();
+    }
+    
+    /**
+     * Get the "particle" method for this atomic test.
+     * 
+     * @param runner JUnit test runner
+     * @param description JUnit method description
+     * @return list of "particle" methods
+     */
+    private List<FrameworkMethod> getParticles(Object runner, Description description) {
+        List<FrameworkMethod> particles = new ArrayList<>();
+        if (description.isTest()) {
+            TestClass testClass = LifecycleHooks.getTestClassOf(runner);
+            
+            String methodName = description.getMethodName();
+            Matcher matcher = PARAM.matcher(methodName);
+            if (matcher.find()) {
+                methodName = methodName.substring(0, matcher.start());
+            }
+            
+            FrameworkMethod identity = null;
+            for (FrameworkMethod method : testClass.getAnnotatedMethods()) {
+                if (method.getName().equals(methodName)) {
+                    identity = method;
+                    break;
+                }
+            }
+            
+            if (identity != null) {
+                particles.add(identity);
+                particles.addAll(testClass.getAnnotatedMethods(Before.class));
+                particles.addAll(testClass.getAnnotatedMethods(After.class));
+            } else {
+                throw new IllegalStateException("Identity method not found");
+            }
+        }
+        
+        return particles;
     }
 }

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

@@ -1,85 +1,126 @@
 package com.nordstrom.automation.junit;
 
+import static com.nordstrom.automation.junit.LifecycleHooks.toMapKey;
+
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.runners.model.FrameworkMethod;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.base.Function;
+
+import net.bytebuddy.implementation.bind.annotation.Argument;
 import net.bytebuddy.implementation.bind.annotation.RuntimeType;
 import net.bytebuddy.implementation.bind.annotation.SuperCall;
 import net.bytebuddy.implementation.bind.annotation.This;
 
-import static com.nordstrom.automation.junit.LifecycleHooks.toMapKey;
-
 /**
  * This class declares the interceptor for the {@link org.junit.runners.BlockJUnit4ClassRunner#createTest
  * createTest} method.
  */
-@SuppressWarnings("squid:S1118")
 public class CreateTest {
 
-    private static final Map<String, Object> TARGET_TO_RUNNER = new ConcurrentHashMap<>();
-    private static final Map<String, Object> RUNNER_TO_TARGET = new ConcurrentHashMap<>();
+    private static final Map<Integer, Object> HASHCODE_TO_TARGET = new ConcurrentHashMap<>();
+    private static final Map<String, FrameworkMethod> TARGET_TO_METHOD = new ConcurrentHashMap<>();
+    private static final ThreadLocal<ConcurrentMap<Integer, DepthGauge>> METHOD_DEPTH;
+    private static final Function<Integer, DepthGauge> NEW_INSTANCE;
     private static final Logger LOGGER = LoggerFactory.getLogger(CreateTest.class);
+
+    static {
+        METHOD_DEPTH = new ThreadLocal<ConcurrentMap<Integer, DepthGauge>>() {
+            @Override
+            protected ConcurrentMap<Integer, DepthGauge> initialValue() {
+                return new ConcurrentHashMap<>();
+            }
+        };
+        NEW_INSTANCE = new Function<Integer, DepthGauge>() {
+            @Override
+            public DepthGauge apply(Integer input) {
+                return new DepthGauge();
+            }
+        };
+    }
 
     /**
      * Interceptor for the {@link org.junit.runners.BlockJUnit4ClassRunner#createTest createTest} method.
      * 
      * @param runner target {@link org.junit.runners.BlockJUnit4ClassRunner BlockJUnit4ClassRunner} object
+     * @param method {@link FrameworkMethod} for which this test class instance is being created
      * @param proxy callable proxy for the intercepted method
      * @return {@code anything} - JUnit test class instance
      * @throws Exception {@code anything} (exception thrown by the intercepted method)
      */
     @RuntimeType
-    public static Object intercept(@This final Object runner,
+    public static Object intercept(@This final Object runner, @Argument(0) final FrameworkMethod method,
                     @SuperCall final Callable<?> proxy) throws Exception {
 
+        Integer hashCode = Objects.hash(runner, method);
+        DepthGauge depthGauge = LifecycleHooks.computeIfAbsent(METHOD_DEPTH.get(), hashCode, NEW_INSTANCE);
+        depthGauge.increaseDepth();
+        
         Object target = LifecycleHooks.callProxy(proxy);
-        // apply parameter-based global timeout
-        TimeoutUtils.applyTestTimeout(runner, target);
 
-        if (null == TARGET_TO_RUNNER.put(toMapKey(target), runner)) {
+        if (0 == depthGauge.decreaseDepth()) {
+            METHOD_DEPTH.remove();
             LOGGER.debug("testObjectCreated: {}", target);
-            RUNNER_TO_TARGET.put(toMapKey(runner), target);
+            TARGET_TO_METHOD.put(toMapKey(target), method);
+            
+            // apply parameter-based global timeout
+            TimeoutUtils.applyTestTimeout(runner, method, target);
+            
+            // if notifier hasn't been initialized yet
+            if ( ! EachTestNotifierInit.setTestTarget(runner, method, target)) {
+                // store target for subsequent retrieval
+                HASHCODE_TO_TARGET.put(hashCode, target);
+            }
 
             for (TestObjectWatcher watcher : LifecycleHooks.getObjectWatchers()) {
-                watcher.testObjectCreated(target, runner);
+                watcher.testObjectCreated(runner, method, target);
             }
         }
 
         return target;
     }
 
     /**
-     * Get the class runner associated with the specified instance.
+     * Get test class instance associated with the specified runner/method pair.
+     * <p>
+     * <b>NOTE</b>: This method can only be called once per target, as it removes the mapping.
      * 
-     * @param target instance of JUnit test class
-     * @return {@link org.junit.runners.BlockJUnit4ClassRunner BlockJUnit4ClassRunner} for specified instance
+     * @param runner JUnit class runner
+     * @param method JUnit framework method
+     * @return target test class instance
      */
-    static Object getRunnerForTarget(Object target) {
-        return TARGET_TO_RUNNER.get(toMapKey(target));
+    static Object getTargetFor(Object runner, FrameworkMethod method) {
+        return HASHCODE_TO_TARGET.remove(Objects.hash(runner, method));
     }
 
     /**
-     * Get the JUnit test class instance for the specified class runner.
+     * Get the method for which the specified test class instance was created.
      * 
-     * @param runner JUnit class runner
-     * @return JUnit test class instance for specified runner
+     * @param target test class instance
+     * @return JUnit framework method
      */
-    static Object getTargetForRunner(Object runner) {
-        return RUNNER_TO_TARGET.get(toMapKey(runner));
+    static FrameworkMethod getMethodFor(Object target) {
+        return TARGET_TO_METHOD.get(toMapKey(target));
     }
 
     /**
-     * Release runner/target mappings.
+     * Release the mappings associated with the specified runner/method/target group.
      * 
      * @param runner JUnit class runner
+     * @param method JUnit framework method
+     * @param target test class instance
      */
-    static void releaseMappingsFor(Object runner) {
-        Object target = RUNNER_TO_TARGET.remove(toMapKey(runner));
+    static void releaseMappingsFor(Object runner, FrameworkMethod method, Object target) {
+        HASHCODE_TO_TARGET.remove(Objects.hash(runner, method));
         if (target != null) {
-            TARGET_TO_RUNNER.remove(toMapKey(target));
+            TARGET_TO_METHOD.remove(toMapKey(target));
         }
     }
 }