Change how the synthetic stack trace frame is inserted to use InvocationInterceptor. This works for dynamic tests as well. Fixes #11.

Author: dweiss

randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/internals/RandomizedContextExtension.java

@@ -6,26 +6,27 @@
 import com.carrotsearch.randomizedtesting.jupiter.Seed;
 import com.carrotsearch.randomizedtesting.jupiter.SeedChain;
 import com.carrotsearch.randomizedtesting.jupiter.SysProps;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Random;
 import java.util.function.LongFunction;
+import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.DynamicTestInvocationContext;
 import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.jupiter.api.extension.LifecycleMethodExecutionExceptionHandler;
+import org.junit.jupiter.api.extension.InvocationInterceptor;
 import org.junit.jupiter.api.extension.ParameterContext;
 import org.junit.jupiter.api.extension.ParameterResolutionException;
 import org.junit.jupiter.api.extension.ParameterResolver;
-import org.junit.jupiter.api.extension.TestExecutionExceptionHandler;
+import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
 
 public class RandomizedContextExtension
-    implements ParameterResolver,
-        BeforeAllCallback,
-        TestExecutionExceptionHandler,
-        LifecycleMethodExecutionExceptionHandler {
+    implements ParameterResolver, BeforeAllCallback, InvocationInterceptor {
   private static final ExtensionContext.Namespace EXTENSION_NAMESPACE =
       ExtensionContext.Namespace.create(RandomizedContextExtension.class);
 
@@ -131,7 +132,7 @@ public Object resolveParameter(
   // internal handling of randomized contexts within junit contexts.
   //
 
-  private RandomizedContextImpl getRandomizedContextFor(ExtensionContext extensionContext) {
+  private static RandomizedContextImpl getRandomizedContextFor(ExtensionContext extensionContext) {
     var store =
         extensionContext.getStore(
             ExtensionContext.StoreScope.EXTENSION_CONTEXT, EXTENSION_NAMESPACE);
@@ -153,37 +154,97 @@ private RandomizedContextImpl getRandomizedContextFor(ExtensionContext extension
   // exception handling and seed stack frame injection
   //
 
+  private static <T> T wrapInvoke(Invocation<T> invocation, ExtensionContext context)
+      throws Throwable {
+    try {
+      return invocation.proceed();
+    } catch (Throwable throwable) {
+      throw addSeedChainStackFrame(throwable, getRandomizedContextFor(context).getSeedChain());
+    }
+  }
+
   @Override
-  public void handleTestExecutionException(ExtensionContext context, Throwable throwable)
+  public <T> T interceptTestClassConstructor(
+      Invocation<T> invocation,
+      ReflectiveInvocationContext<Constructor<T>> invocationContext,
+      ExtensionContext extensionContext)
       throws Throwable {
-    throw addSeedChainStackFrame(throwable, getRandomizedContextFor(context).getSeedChain());
+    return wrapInvoke(invocation, extensionContext);
   }
 
   @Override
-  public void handleBeforeAllMethodExecutionException(ExtensionContext context, Throwable throwable)
+  public void interceptBeforeAllMethod(
+      Invocation<@Nullable Void> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
       throws Throwable {
-    throw addSeedChainStackFrame(throwable, getRandomizedContextFor(context).getSeedChain());
+    wrapInvoke(invocation, extensionContext);
   }
 
   @Override
-  public void handleBeforeEachMethodExecutionException(
-      ExtensionContext context, Throwable throwable) throws Throwable {
-    throw addSeedChainStackFrame(throwable, getRandomizedContextFor(context).getSeedChain());
+  public void interceptBeforeEachMethod(
+      Invocation<@Nullable Void> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
+      throws Throwable {
+    wrapInvoke(invocation, extensionContext);
+  }
+
+  @Override
+  public void interceptTestMethod(
+      Invocation<@Nullable Void> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
+      throws Throwable {
+    wrapInvoke(invocation, extensionContext);
+  }
+
+  @Override
+  public <T> T interceptTestFactoryMethod(
+      Invocation<T> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
+      throws Throwable {
+    return wrapInvoke(invocation, extensionContext);
+  }
+
+  @Override
+  public void interceptTestTemplateMethod(
+      Invocation<@Nullable Void> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
+      throws Throwable {
+    wrapInvoke(invocation, extensionContext);
+  }
+
+  @Override
+  public void interceptAfterEachMethod(
+      Invocation<@Nullable Void> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
+      throws Throwable {
+    wrapInvoke(invocation, extensionContext);
   }
 
   @Override
-  public void handleAfterEachMethodExecutionException(ExtensionContext context, Throwable throwable)
+  public void interceptAfterAllMethod(
+      Invocation<@Nullable Void> invocation,
+      ReflectiveInvocationContext<Method> invocationContext,
+      ExtensionContext extensionContext)
       throws Throwable {
-    throw addSeedChainStackFrame(throwable, getRandomizedContextFor(context).getSeedChain());
+    wrapInvoke(invocation, extensionContext);
   }
 
   @Override
-  public void handleAfterAllMethodExecutionException(ExtensionContext context, Throwable throwable)
+  public void interceptDynamicTest(
+      Invocation<@Nullable Void> invocation,
+      DynamicTestInvocationContext invocationContext,
+      ExtensionContext extensionContext)
       throws Throwable {
-    throw addSeedChainStackFrame(throwable, getRandomizedContextFor(context).getSeedChain());
+    wrapInvoke(invocation, extensionContext);
   }
 
-  private Throwable addSeedChainStackFrame(Throwable throwable, SeedChain seedChain) {
+  private static Throwable addSeedChainStackFrame(Throwable throwable, SeedChain seedChain) {
     List<StackTraceElement> stack = new ArrayList<>(Arrays.asList(throwable.getStackTrace()));
     stack.addFirst(
         new StackTraceElement(Constants.AUGMENTED_SEED_CLASS, "seed", seedChain.toString(), -1));

randomizedtesting-jupiter/src/test/java/com/carrotsearch/randomizedtesting/tests/F002_SeedRecovery.java

@@ -54,6 +54,7 @@ Stream<DynamicTest> dynamicTestsFromIterator() {
               new Check("@BeforeAll", AtBeforeAll.class, "[DEAD:BEEF]"),
               new Check("@BeforeEach", AtBeforeEachLevel.class, "[DEAD:BEEF:CAFE]"),
               new Check("@Test", AtTestLevel.class, "[DEAD:BEEF:CAFE]"),
+              new Check("@TestFactory", InDynamicTest.class, "[DEAD:BEEF:CAFE:"),
               new Check("@AfterEach", AtAfterEachLevel.class, "[DEAD:BEEF:CAFE]"),
               new Check("@AfterAll", AtAfterAll.class, "[DEAD:BEEF]"))
           .map(e -> DynamicTest.dynamicTest(e.name(), () -> runCheck(e)));
@@ -76,15 +77,25 @@ private void runCheck(Check e) {
                           t -> {
                             Assertions.assertThat(t.getStackTrace()[0].toString())
                                 .contains(
-                                    Constants.AUGMENTED_SEED_CLASS
-                                        + ".seed("
-                                        + e.expectedSeed
-                                        + ")");
+                                    Constants.AUGMENTED_SEED_CLASS + ".seed(" + e.expectedSeed);
                             return true;
                           },
                           "first stack frame contains seed entry"))));
     }
 
+    @Randomized
+    static class InDynamicTest extends IgnoreInStandaloneRuns {
+      @TestFactory
+      public Stream<DynamicTest> dynamicTests() {
+        return Stream.of(
+            DynamicTest.dynamicTest(
+                "dynamicTest",
+                () -> {
+                  throw new AssertionError("Failure.");
+                }));
+      }
+    }
+
     @Randomized
     static class AtBeforeAll extends IgnoreInStandaloneRuns {
       @BeforeAll