--- jsr166/src/test/tck/ThreadLocalRandomTest.java	2013/09/25 07:39:17	1.18
+++ jsr166/src/test/tck/ThreadLocalRandomTest.java	2017/09/19 20:10:49	1.25
@@ -3,16 +3,18 @@
  * Expert Group and released to the public domain, as explained at
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
-import junit.framework.*;
-import java.util.*;
+
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
 public class ThreadLocalRandomTest extends JSR166TestCase {
 
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
     public static Test suite() {
         return new TestSuite(ThreadLocalRandomTest.class);
@@ -50,6 +52,53 @@ public class ThreadLocalRandomTest exten
     }
 
     /**
+     * Repeated calls to next (only accessible via reflection) produce
+     * at least two distinct results, and repeated calls produce all
+     * possible values.
+     */
+    public void testNext() throws ReflectiveOperationException {
+        // Inhibit "An illegal reflective access operation has occurred"
+        if (!testImplementationDetails) return;
+
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        final java.lang.reflect.Method m;
+        try {
+            m = ThreadLocalRandom.class.getDeclaredMethod(
+                    "next", new Class[] { int.class });
+            m.setAccessible(true);
+        } catch (SecurityException acceptable) {
+            // Security manager may deny access
+            return;
+        } catch (Exception ex) {
+            // jdk9 module system may deny access
+            if (ex.getClass().getSimpleName()
+                .equals("InaccessibleObjectException"))
+                return;
+            throw ex;
+        }
+
+        int i;
+        {
+            int val = new java.util.Random().nextInt(4);
+            for (i = 0; i < NCALLS; i++) {
+                int q = (int) m.invoke(rnd, new Object[] { 2 });
+                if (val == q) break;
+            }
+            assertTrue(i < NCALLS);
+        }
+
+        {
+            int r = (int) m.invoke(rnd, new Object[] { 3 });
+            for (i = 0; i < NCALLS; i++) {
+                int q = (int) m.invoke(rnd, new Object[] { 3 });
+                assertTrue(q < (1<<3));
+                if (r != q) break;
+            }
+            assertTrue(i < NCALLS);
+        }
+    }
+
+    /**
      * Repeated calls to nextInt produce at least two distinct results
      */
     public void testNextInt() {
@@ -116,23 +165,34 @@ public class ThreadLocalRandomTest exten
     }
 
     /**
-     * nextInt(negative) throws IllegalArgumentException
+     * nextInt(non-positive) throws IllegalArgumentException
      */
-    public void testNextIntBoundedNeg() {
-        try {
-            int f = ThreadLocalRandom.current().nextInt(-17);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
+    public void testNextIntBoundNonPositive() {
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
+            try {
+                rnd.nextInt(bound);
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
+        }
     }
 
     /**
      * nextInt(least >= bound) throws IllegalArgumentException
      */
     public void testNextIntBadBounds() {
-        try {
-            int f = ThreadLocalRandom.current().nextInt(17, 2);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
+        int[][] badBoundss = {
+            { 17, 2 },
+            { -42, -42 },
+            { Integer.MAX_VALUE, Integer.MIN_VALUE },
+        };
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        for (int[] badBounds : badBoundss) {
+            try {
+                rnd.nextInt(badBounds[0], badBounds[1]);
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
+        }
     }
 
     /**
@@ -177,23 +237,34 @@ public class ThreadLocalRandomTest exten
     }
 
     /**
-     * nextLong(negative) throws IllegalArgumentException
+     * nextLong(non-positive) throws IllegalArgumentException
      */
-    public void testNextLongBoundedNeg() {
-        try {
-            long f = ThreadLocalRandom.current().nextLong(-17);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
+    public void testNextLongBoundNonPositive() {
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
+            try {
+                rnd.nextLong(bound);
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
+        }
     }
 
     /**
      * nextLong(least >= bound) throws IllegalArgumentException
      */
     public void testNextLongBadBounds() {
-        try {
-            long f = ThreadLocalRandom.current().nextLong(17, 2);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
+        long[][] badBoundss = {
+            { 17L, 2L },
+            { -42L, -42L },
+            { Long.MAX_VALUE, Long.MIN_VALUE },
+        };
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        for (long[] badBounds : badBoundss) {
+            try {
+                rnd.nextLong(badBounds[0], badBounds[1]);
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
+        }
     }
 
     /**
@@ -236,6 +307,26 @@ public class ThreadLocalRandomTest exten
         }
     }
 
+    /**
+     * nextDouble(non-positive) throws IllegalArgumentException
+     */
+    public void testNextDoubleBoundNonPositive() {
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        double[] badBounds = {
+            0.0d,
+            -17.0d,
+            -Double.MIN_VALUE,
+            Double.NEGATIVE_INFINITY,
+            Double.NaN,
+        };
+        for (double bound : badBounds) {
+            try {
+                rnd.nextDouble(bound);
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
+        }
+    }
+
     /**
      * nextDouble(least, bound) returns least <= value < bound;
      * repeated calls produce at least two distinct results