test execution context is handed through from engine to test methods

junit-engine-api/src/main/java/org/junit/gen5/engine/ExecutionRequest.java

@@ -12,7 +12,6 @@
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Stack;
 
 import lombok.Value;
 
@@ -25,6 +24,4 @@ public class ExecutionRequest {
 
 	private Map<String, Object> attributes = new HashMap<>();
 
-	private Stack<Object> testInstances = new Stack<>();
-
 }

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/ClassTestExecutionNode.java

@@ -60,24 +60,18 @@ public void execute(ExecutionRequest request, TestExecutionContext context) {
 		}
 
 		Object testInstance = createTestInstance();
-		request.getTestInstances().push(testInstance);
 
 		try {
 			executeBeforeAllMethods(testClass, testInstance);
 			for (TestExecutionNode child : getChildren()) {
-				executeChild(child, request, context);
+				executeChild(child, request, context, testInstance);
 			}
 		}
 		catch (Exception e) {
 			request.getTestExecutionListener().testFailed(getTestDescriptor(), e);
 		}
 		finally {
-			try {
-				executeAfterAllMethods(request, testClass, testInstance);
-			}
-			finally {
-				request.getTestInstances().pop();
-			}
+			executeAfterAllMethods(request, testClass, testInstance);
 		}
 	}
 

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/EngineTestExecutionNode.java

@@ -35,13 +35,17 @@ public EngineDescriptor getTestDescriptor() {
 	@Override
 	public void execute(ExecutionRequest request, TestExecutionContext context) {
 		for (TestExecutionNode child : getChildren()) {
-			executeChild(child, request, context);
+			executeChild(child, request, context, null);
 		}
 	}
 
 	public void executeRequest(ExecutionRequest request) {
-		TestExecutionContext context = createChildContext(getTestDescriptor(), null);
+		TestExecutionContext context = createTopLevelContext();
 		execute(request, context);
 	}
 
+	private TestExecutionContext createTopLevelContext() {
+		return createContext(getTestDescriptor(), null, null, null, null);
+	}
+
 }

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/MethodTestExecutionNode.java

@@ -14,9 +14,6 @@
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
 
 import org.junit.gen5.api.After;
 import org.junit.gen5.api.Before;
@@ -68,13 +65,13 @@ public void execute(ExecutionRequest request, TestExecutionContext context) {
 		}
 
 		request.getTestExecutionListener().testStarted(getTestDescriptor());
-		Object testInstance = request.getTestInstances().peek();
+		Object testInstance = context.getTestInstance().get();
 		Class<?> testClass = testInstance.getClass();
 		Throwable exceptionThrown = null;
 
 		try {
-			executeBeforeMethods(request, testClass, testInstance);
-			invokeTestMethod(request, testInstance);
+			executeBeforeMethods(context);
+			invokeTestMethod(context.getTestMethod().get(), context);
 		}
 		catch (Throwable ex) {
 			exceptionThrown = ex;
@@ -83,7 +80,7 @@ public void execute(ExecutionRequest request, TestExecutionContext context) {
 			}
 		}
 		finally {
-			exceptionThrown = executeAfterMethods(request, testClass, testInstance, exceptionThrown);
+			exceptionThrown = executeAfterMethods(context, exceptionThrown);
 		}
 
 		if (exceptionThrown != null) {
@@ -102,61 +99,35 @@ else if (exceptionThrown instanceof TestAbortedException) {
 		}
 	}
 
-	private void invokeMethod(ExecutionRequest request, Method method, Object target) {
+	private void invokeMethod(Method method, TestExecutionContext context) {
 		MethodArgumentResolverRegistry resolverRegistry = buildMethodArgumentResolverRegistry();
-		populateRegistryForMethod(resolverRegistry, method);
+		populateRegistryForMethod(resolverRegistry, context.getTestMethod().get());
 
-		MethodInvoker methodInvoker = new MethodInvoker(method, target, resolverRegistry.getResolvers());
+		MethodInvoker methodInvoker = new MethodInvoker(method, context.getTestInstance().get(),
+			resolverRegistry.getResolvers());
 
 		// TODO Introduce factory for TestExecutionContext instances.
 		// TODO Cache & reuse TestExecutionContext instance so extensions can share state.
-		methodInvoker.invoke(new TestExecutionContext() {
-
-			private final Map<String, Object> attributes = new HashMap<>();
-
-			@Override
-			public Optional<Class<?>> getTestClass() {
-				return Optional.of(getTestDescriptor().getTestMethod().getDeclaringClass());
-			}
-
-			@Override
-			public Optional<Method> getTestMethod() {
-				return Optional.of(getTestDescriptor().getTestMethod());
-			}
-
-			@Override
-			public Optional<Object> getTestInstance() {
-				return Optional.of(target);
-			}
-
-			@Override
-			public String getDisplayName() {
-				return getTestDescriptor().getDisplayName();
-			}
-
-			@Override
-			public Map<String, Object> getAttributes() {
-				return this.attributes;
-			}
-		});
+		methodInvoker.invoke(context);
 	}
 
-	private void invokeTestMethod(ExecutionRequest context, Object testInstance) {
-		invokeMethod(context, getTestDescriptor().getTestMethod(), testInstance);
+	private void invokeTestMethod(Method method, TestExecutionContext context) {
+		invokeMethod(method, context);
 	}
 
-	private void executeBeforeMethods(ExecutionRequest context, Class<?> testClass, Object testInstance) {
-		for (Method method : findAnnotatedMethods(testClass, Before.class, MethodSortOrder.HierarchyDown)) {
-			invokeMethod(context, method, testInstance);
+	private void executeBeforeMethods(TestExecutionContext context) {
+		for (Method method : findAnnotatedMethods(context.getTestClass().get(), Before.class,
+			MethodSortOrder.HierarchyDown)) {
+			invokeMethod(method, context);
 		}
 	}
 
-	private Throwable executeAfterMethods(ExecutionRequest context, Class<?> testClass, Object testInstance,
-			Throwable exceptionThrown) {
+	private Throwable executeAfterMethods(TestExecutionContext context, Throwable exceptionThrown) {
 
-		for (Method method : findAnnotatedMethods(testClass, After.class, MethodSortOrder.HierarchyUp)) {
+		for (Method method : findAnnotatedMethods(context.getTestClass().get(), After.class,
+			MethodSortOrder.HierarchyUp)) {
 			try {
-				invokeMethod(context, method, testInstance);
+				invokeMethod(method, context);
 			}
 			catch (Throwable ex) {
 				Throwable currentException = ex;

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/TestExecutionNode.java

@@ -10,6 +10,7 @@
 
 package org.junit.gen5.engine.junit5.execution;
 
+import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedList;
@@ -20,6 +21,8 @@
 import org.junit.gen5.api.extension.TestExecutionContext;
 import org.junit.gen5.engine.ExecutionRequest;
 import org.junit.gen5.engine.TestDescriptor;
+import org.junit.gen5.engine.junit5.descriptor.ClassTestDescriptor;
+import org.junit.gen5.engine.junit5.descriptor.MethodTestDescriptor;
 
 /**
  * @author Stefan Bechtold
@@ -49,12 +52,35 @@ public final List<TestExecutionNode> getChildren() {
 
 	public abstract void execute(ExecutionRequest request, TestExecutionContext context);
 
-	protected void executeChild(TestExecutionNode child, ExecutionRequest request, TestExecutionContext parentContext) {
-		TestExecutionContext childContext = createChildContext(child.getTestDescriptor(), parentContext);
+	protected void executeChild(TestExecutionNode child, ExecutionRequest request, TestExecutionContext parentContext,
+			Object testInstance) {
+
+		TestExecutionContext childContext = createChildContext(child, parentContext, testInstance);
 		child.execute(request, childContext);
+
+	}
+
+	private TestExecutionContext createChildContext(TestExecutionNode child, TestExecutionContext parentContext,
+			Object testInstance) {
+		Class<?> testClass = null;
+		Method testMethod = null;
+
+		if (child.getTestDescriptor() instanceof ClassTestDescriptor) {
+			//also handles ContextTestDescriptor which is subclass of CTD
+			testClass = ((ClassTestDescriptor) child.getTestDescriptor()).getTestClass();
+		}
+
+		if (child.getTestDescriptor() instanceof MethodTestDescriptor) {
+			MethodTestDescriptor methodTestDescriptor = (MethodTestDescriptor) child.getTestDescriptor();
+			testMethod = methodTestDescriptor.getTestMethod();
+			testClass = ((ClassTestDescriptor) methodTestDescriptor.getParent().get()).getTestClass();
+		}
+		return createContext(child.getTestDescriptor(), parentContext, testInstance, testMethod, testClass);
 	}
 
-	protected TestExecutionContext createChildContext(TestDescriptor descriptor, TestExecutionContext parent) {
+	protected TestExecutionContext createContext(TestDescriptor descriptor, TestExecutionContext parent,
+			Object testInstance, Method testMethod, Class testClass) {
+
 		return new TestExecutionContext() {
 
 			private final Map<String, Object> attributes = new HashMap<>();
@@ -73,6 +99,21 @@ public Map<String, Object> getAttributes() {
 			public Optional<TestExecutionContext> getParent() {
 				return Optional.ofNullable(parent);
 			}
+
+			@Override
+			public Optional<Object> getTestInstance() {
+				return Optional.ofNullable(testInstance);
+			}
+
+			@Override
+			public Optional<Method> getTestMethod() {
+				return Optional.ofNullable(testMethod);
+			}
+
+			@Override
+			public Optional<Class<?>> getTestClass() {
+				return Optional.ofNullable(testClass);
+			}
 		};
 	}