--- jsr166/src/test/tck/ThreadLocalRandomTest.java 2009/07/31 23:37:31 1.2 +++ jsr166/src/test/tck/ThreadLocalRandomTest.java 2020/08/12 17:39:43 1.30 @@ -1,23 +1,26 @@ /* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain + * http://creativecommons.org/publicdomain/zero/1.0/ */ -import junit.framework.*; -import java.util.concurrent.*; -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); + return new TestSuite(ThreadLocalRandomTest.class); } - /** + /* * Testing coverage notes: * * We don't test randomness properties, but only that repeated @@ -26,27 +29,76 @@ public class ThreadLocalRandomTest exten * across multiples of primes. */ - // + // max numbers of calls to detect getting stuck on one value static final int NCALLS = 10000; // max sampled int bound static final int MAX_INT_BOUND = (1 << 28); - // Max sampled long bound + // max sampled long bound static final long MAX_LONG_BOUND = (1L << 42); + // Number of replications for other checks + static final int REPS = 20; + /** * setSeed throws UnsupportedOperationException */ public void testSetSeed() { try { ThreadLocalRandom.current().setSeed(17); - } catch (UnsupportedOperationException success) { + shouldThrow(); + } catch (UnsupportedOperationException success) {} + } + + /** + * 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", 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 one different result + * Repeated calls to nextInt produce at least two distinct results */ public void testNextInt() { int f = ThreadLocalRandom.current().nextInt(); @@ -57,7 +109,7 @@ public class ThreadLocalRandomTest exten } /** - * Repeated calls to nextLong produce at least one different result + * Repeated calls to nextLong produce at least two distinct results */ public void testNextLong() { long f = ThreadLocalRandom.current().nextLong(); @@ -67,9 +119,8 @@ public class ThreadLocalRandomTest exten assertTrue(i < NCALLS); } - /** - * Repeated calls to nextBoolean produce at least one different result + * Repeated calls to nextBoolean produce at least two distinct results */ public void testNextBoolean() { boolean f = ThreadLocalRandom.current().nextBoolean(); @@ -80,7 +131,7 @@ public class ThreadLocalRandomTest exten } /** - * Repeated calls to nextFloat produce at least one different result + * Repeated calls to nextFloat produce at least two distinct results */ public void testNextFloat() { float f = ThreadLocalRandom.current().nextFloat(); @@ -91,18 +142,18 @@ public class ThreadLocalRandomTest exten } /** - * Repeated calls to nextDouble produce at least one different result + * Repeated calls to nextDouble produce at least two distinct results */ public void testNextDouble() { double f = ThreadLocalRandom.current().nextDouble(); - double i = 0; + int i = 0; while (i < NCALLS && ThreadLocalRandom.current().nextDouble() == f) ++i; assertTrue(i < NCALLS); } /** - * Repeated calls to nextGaussian produce at least one different result + * Repeated calls to nextGaussian produce at least two distinct results */ public void testNextGaussian() { double f = ThreadLocalRandom.current().nextGaussian(); @@ -112,31 +163,40 @@ public class ThreadLocalRandomTest exten assertTrue(i < NCALLS); } - /** - * nextInt(negative) throws IllegalArgumentException; + * nextInt(non-positive) throws IllegalArgumentException */ - public void testNextIntBoundedNeg() { - try { - int f = ThreadLocalRandom.current().nextInt(-17); - } 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; + * nextInt(least >= bound) throws IllegalArgumentException */ public void testNextIntBadBounds() { - try { - int f = ThreadLocalRandom.current().nextInt(17, 2); - } 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) {} } } - /** * nextInt(bound) returns 0 <= value < bound; - * repeated calls produce at least one different result + * repeated calls produce at least two distinct results */ public void testNextIntBounded() { // sample bound space across prime number increments @@ -154,10 +214,9 @@ public class ThreadLocalRandomTest exten } } - /** * nextInt(least, bound) returns least <= value < bound; - * repeated calls produce at least one different result + * repeated calls produce at least two distinct results */ public void testNextIntBounded2() { for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) { @@ -177,28 +236,39 @@ public class ThreadLocalRandomTest exten } /** - * nextLong(negative) throws IllegalArgumentException; + * nextLong(non-positive) throws IllegalArgumentException */ - public void testNextLongBoundedNeg() { - try { - long f = ThreadLocalRandom.current().nextLong(-17); - } 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; + * nextLong(least >= bound) throws IllegalArgumentException */ public void testNextLongBadBounds() { - try { - long f = ThreadLocalRandom.current().nextLong(17, 2); - } 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) {} } } /** * nextLong(bound) returns 0 <= value < bound; - * repeated calls produce at least one different result + * repeated calls produce at least two distinct results */ public void testNextLongBounded() { for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) { @@ -217,7 +287,7 @@ public class ThreadLocalRandomTest exten /** * nextLong(least, bound) returns least <= value < bound; - * repeated calls produce at least one different result + * repeated calls produce at least two distinct results */ public void testNextLongBounded2() { for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) { @@ -236,10 +306,29 @@ 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 one different result + * repeated calls produce at least two distinct results */ public void testNextDoubleBounded2() { for (double least = 0.0001; least < 1.0e20; least *= 8) { @@ -258,5 +347,72 @@ public class ThreadLocalRandomTest exten } } + /** + * Different threads produce different pseudo-random sequences + */ + public void testDifferentSequences() { + // Don't use main thread's ThreadLocalRandom - it is likely to + // be polluted by previous tests. + final AtomicReference threadLocalRandom = + new AtomicReference<>(); + final AtomicLong rand = new AtomicLong(); + + Runnable getRandomState = new CheckedRunnable() { + public void realRun() { + ThreadLocalRandom current = ThreadLocalRandom.current(); + assertSame(current, ThreadLocalRandom.current()); + rand.set(current.nextLong()); + threadLocalRandom.set(current); + }}; + + awaitTermination(newStartedThread(getRandomState)); + long firstRand = rand.get(); + ThreadLocalRandom firstThreadLocalRandom = threadLocalRandom.get(); + assertNotNull(firstThreadLocalRandom); + + for (int i = 0; i < NCALLS; i++) { + awaitTermination(newStartedThread(getRandomState)); + if (testImplementationDetails) + // ThreadLocalRandom has been a singleton since jdk8. + assertSame(firstThreadLocalRandom, threadLocalRandom.get()); + if (firstRand != rand.get()) + return; + } + fail("all threads generate the same pseudo-random sequence"); + } + + /** + * Repeated calls to nextBytes produce at least values of different signs for every byte + */ + public void testNextBytes() { + ThreadLocalRandom rnd = ThreadLocalRandom.current(); + int n = rnd.nextInt(1, 20); + byte[] bytes = new byte[n]; + outer: + for (int i = 0; i < n; i++) { + for (int tries = NCALLS; tries-->0; ) { + byte before = bytes[i]; + rnd.nextBytes(bytes); + byte after = bytes[i]; + if (after * before < 0) + continue outer; + } + fail("not enough variation in random bytes"); + } + } + + /** + * Filling an empty array with random bytes succeeds without effect. + */ + public void testNextBytes_emptyArray() { + ThreadLocalRandom.current().nextBytes(new byte[0]); + } + + public void testNextBytes_nullArray() { + try { + ThreadLocalRandom.current().nextBytes(null); + shouldThrow(); + } catch (NullPointerException success) {} + } }