Add support for Supplier<Random> injection.

Author: dweiss

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

@@ -8,13 +8,16 @@
 import com.carrotsearch.randomizedtesting.jupiter.SysProps;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 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 java.util.function.Supplier;
 import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.extension.BeforeAllCallback;
 import org.junit.jupiter.api.extension.DynamicTestInvocationContext;
@@ -103,28 +106,44 @@ private static SeedChain parseRootSeed(Optional<String> rootSeedValue) {
   //
   // ParameterResolver: inject RandomizedContext and Random instances into test methods.
   //
+  private static final Type supplierOfRandom = getSupplierOfRandomType();
+
+  /** Helper method that returns parameterized type for {@code Supplier<Random>}. */
+  private static Type getSupplierOfRandomType() {
+    abstract class TypeLiteral<T> {
+      public Type getType() {
+        return ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
+      }
+    }
+
+    return (new TypeLiteral<Supplier<Random>>() {}).getType();
+  }
 
   @Override
   public boolean supportsParameter(
       ParameterContext parameterContext, ExtensionContext extensionContext)
       throws ParameterResolutionException {
-    Class<?> parameterType = parameterContext.getParameter().getType();
-    return parameterType.equals(RandomizedContext.class) || parameterType.equals(Random.class);
+    var type = parameterContext.getParameter().getParameterizedType();
+    return type.equals(RandomizedContext.class)
+        || type.equals(Random.class)
+        || type.equals(supplierOfRandom);
   }
 
   @Override
   public Object resolveParameter(
       ParameterContext parameterContext, ExtensionContext extensionContext)
       throws ParameterResolutionException {
     var ctx = getRandomizedContextFor(extensionContext);
-    Class<?> parameterType = parameterContext.getParameter().getType();
-    if (parameterType.equals(RandomizedContext.class)) {
+    var type = parameterContext.getParameter().getParameterizedType();
+    if (type.equals(RandomizedContext.class)) {
       return ctx;
-    } else if (parameterType.equals(Random.class)) {
+    } else if (type.equals(Random.class)) {
       return ctx.getRandom();
+    } else if (type.equals(supplierOfRandom)) {
+      return (Supplier<Random>) ctx::splitRandom;
     } else {
       throw new RuntimeException(
-          "Unexpected unsupported parameter type in resolveParameter: " + parameterType);
+          "Unexpected unsupported parameter type in resolveParameter: " + type);
     }
   }
 

randomizedtesting-jupiter/src/main/java/module-info.java

@@ -4,6 +4,7 @@
   requires org.junit.jupiter.api;
   requires org.junit.jupiter.params;
   requires java.logging;
+  requires java.compiler;
 
   exports com.carrotsearch.randomizedtesting.jupiter;
   exports com.carrotsearch.randomizedtesting.jupiter.generators;

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

@@ -10,9 +10,11 @@
 import com.carrotsearch.randomizedtesting.jupiter.SysProps;
 import com.carrotsearch.randomizedtesting.tests.infra.IgnoreInStandaloneRuns;
 import java.io.PrintWriter;
+import java.util.HashSet;
 import java.util.Locale;
 import java.util.Random;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
@@ -73,6 +75,78 @@ static void afterAll(Random random) {
     }
   }
 
+  @Nested
+  class TestRandomSupplierInjection {
+    @Test
+    public void testAllHooks() {
+      collectExecutionResults(testKitBuilder(T1.class))
+          .results()
+          .allEvents()
+          .assertThatEvents()
+          .doNotHave(event(finishedWithFailure()));
+    }
+
+    @Randomized
+    static class T1 extends IgnoreInStandaloneRuns {
+      public T1(Supplier<Random> supplier) {
+        check(supplier);
+      }
+
+      @BeforeAll
+      static void beforeAll(Supplier<Random> supplier) {
+        check(supplier);
+      }
+
+      @BeforeEach
+      void beforeEach(Supplier<Random> supplier) {
+        check(supplier);
+      }
+
+      @Test
+      void testMethod(Supplier<Random> supplier) {
+        check(supplier);
+      }
+
+      @AfterEach
+      void afterEach(Supplier<Random> supplier) {
+        check(supplier);
+      }
+
+      @AfterAll
+      static void afterAll(Supplier<Random> supplier) {
+        check(supplier);
+      }
+
+      private static void check(Supplier<Random> supplier) {
+        Assertions.assertThat(supplier).isNotNull();
+        Assertions.assertThat(supplier.get()).isNotNull();
+
+        // ensure any threads that acquire a random from the supplier are started with
+        // the same initial seed.
+        var firstLongs =
+            IntStream.range(0, 5)
+                .mapToObj(
+                    i -> {
+                      try {
+                        AtomicReference<Object> rnd = new AtomicReference<>();
+                        var t =
+                            new Thread(
+                                () -> {
+                                  rnd.set(supplier.get().nextLong());
+                                });
+                        t.start();
+                        t.join();
+                        return rnd.get();
+                      } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                      }
+                    })
+                .toList();
+        Assertions.assertThat(new HashSet<>(firstLongs)).hasSize(1);
+      }
+    }
+  }
+
   @Nested
   class TestRandomFactoryAndState {
     @Test

randomizedtesting-jupiter/src/test/java/com/carrotsearch/randomizedtesting/tests/F003_RandomInjection.md

@@ -17,7 +17,7 @@ public class TestClass {
 
 The injected `Random` is initialized with the context's seed.
 
-* It should be possible to pick (via system properties or JUnit5 configuratoin
+* It should be possible to pick (via system properties or JUnit5 configuration
   parameters) different `Random` implementations for the
   injected parameter. Lockless or those providing larger state space than
   the default `java.util.Random`.
@@ -27,6 +27,10 @@ The injected `Random` is initialized with the context's seed.
   Random instances should verify they are indeed used from within the
   right thread.
 
+* It should be possible to inject a parameter of type `Supplier<Random>`. This
+  supplier is safe to use from any thread; it returns a `Random` instance initialized
+  with the same starting seed if called from a previously unseen thread.
+
 ## Migration notes (from randomizedtesting for junit4)
 
 This is new functionality, it wasn't available before.