Add cross-context assertions to randoms.

Author: dweiss

randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/AssertingRandom.java

@@ -1,5 +1,6 @@
 package com.carrotsearch.randomizedtesting.jupiter;
 
+import java.io.Closeable;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.Random;
@@ -8,7 +9,7 @@
  * A {@link Random} with a delegate, preventing {@link Random#setSeed(long)} and locked to only be
  * usable by a single {@link Thread}.
  */
-final class AssertingRandom extends Random {
+final class AssertingRandom extends Random implements Closeable {
   private final Random delegate;
   private final Thread ownerRef;
   private final String ownerName;
@@ -23,7 +24,7 @@ final class AssertingRandom extends Random {
 
   /**
    * Creates an instance to be used by <code>owner</code> thread and delegating to <code>delegate
-   * </code> until {@link #destroy()}ed.
+   * </code> until {@link #close()}ed.
    */
   public AssertingRandom(Thread owner, Random delegate) {
     // Must be here, the only Random constructor. Has side effects on setSeed, see below.
@@ -118,7 +119,7 @@ public int hashCode() {
   }
 
   /** This object will no longer be usable after this method is called. */
-  void destroy() {
+  public void close() {
     this.valid = false;
   }
 

randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/RandomizedContext.java

@@ -1,12 +1,14 @@
 package com.carrotsearch.randomizedtesting.jupiter;
 
+import java.io.Closeable;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Objects;
 import java.util.Random;
 import org.junit.jupiter.api.extension.ExtensionContext;
 
-public final class RandomizedContext {
+public final class RandomizedContext implements Closeable {
   private final RandomizedContext parent;
   private final Seed seed;
   final String contextId;
@@ -83,4 +85,11 @@ RandomizedContext deriveNew(ExtensionContext extensionContext) {
     return new RandomizedContext(
         extensionContext.getUniqueId(), this, randomFactory, nextSeed, firstAndRest.rest());
   }
+
+  @Override
+  public void close() throws IOException {
+    if (random instanceof Closeable c) {
+      c.close();
+    }
+  }
 }

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

@@ -20,6 +20,7 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.api.TestInstance;
 
 /** Verifies that {@link java.util.Random} instances are properly injected as parameters. */
 public class F003_RandomInjection {
@@ -135,7 +136,11 @@ void testMethod(PrintWriter pw, Random rnd) {
   class TestRandomAssertions {
     @Test
     public void testAllHooks() {
-      collectExecutionResults(testKitBuilder(T1.class))
+      collectExecutionResults(
+              testKitBuilder(T1.class)
+                  .configurationParameter(
+                      RandomizedContextSupplier.SysProps.TESTS_RANDOM_ASSERTING.propertyKey,
+                      "true"))
           .results()
           .allEvents()
           .assertThatEvents()
@@ -165,5 +170,45 @@ void testMethod(Random random) throws Exception {
             .hasMessageContaining("This Random instance is tied to thread");
       }
     }
+
+    @Test
+    public void testAssertingRandomIsClosedAfterContext() {
+      collectExecutionResults(
+              testKitBuilder(T2.class)
+                  .configurationParameter(
+                      RandomizedContextSupplier.SysProps.TESTS_RANDOM_ASSERTING.propertyKey,
+                      "true"))
+          .results()
+          .allEvents()
+          .assertThatEvents()
+          .doNotHave(event(finishedWithFailure()));
+    }
+
+    @Randomized
+    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+    static class T2 extends IgnoreInStandaloneRuns {
+      Random rnd;
+
+      @Test
+      void testMethod1(Random random) throws Exception {
+        check(random);
+      }
+
+      @Test
+      void testMethod2(Random random) throws Exception {
+        check(random);
+      }
+
+      private void check(Random random) {
+        if (rnd == null) {
+          rnd = random;
+        } else {
+          Assertions.assertThat(rnd).isNotSameAs(random);
+          Assertions.assertThatCode(() -> rnd.nextLong())
+              .isExactlyInstanceOf(RuntimeException.class)
+              .hasMessageContaining("This Random instance has been invalidated");
+        }
+      }
+    }
   }
 }

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

@@ -17,6 +17,16 @@ 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
+  parameters) different `Random` implementations for the
+  injected parameter. Lockless or those providing larger state space than
+  the default `java.util.Random`.
+
+* The injected `Random` is tied to the thread that created it. When
+  assertions are enabled (or an explicit parameter is set), the injected
+  Random instances should verify they are indeed used from within the
+  right thread.
+
 ## Migration notes (from randomizedtesting for junit4)
 
 This is new functionality, it wasn't available before.