--- jsr166/src/test/tck/ThreadLocalRandomTest.java 2009/07/31 23:02:50 1.1 +++ jsr166/src/test/tck/ThreadLocalRandomTest.java 2013/08/16 07:07:01 1.16 @@ -1,52 +1,57 @@ /* * 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.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; public class ThreadLocalRandomTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run (suite()); + junit.textui.TestRunner.run(suite()); } 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 * calls, up to NCALLS tries, produce at least one different * result. For bounded versions, we sample various intervals * 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 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 +62,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 +72,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 +84,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 +95,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 +116,29 @@ public class ThreadLocalRandomTest exten assertTrue(i < NCALLS); } - /** - * nextInt(negative) throws IllegalArgumentException; + * nextInt(negative) throws IllegalArgumentException */ public void testNextIntBoundedNeg() { try { - int f = ThreadLocalRandom.current().nextInt(-17); - } catch(IllegalArgumentException success) { - } + int f = ThreadLocalRandom.current().nextInt(-17); + 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 f = ThreadLocalRandom.current().nextInt(17, 2); + 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 @@ -145,7 +147,7 @@ public class ThreadLocalRandomTest exten assertTrue(0 <= f && f < bound); int i = 0; int j; - while (i < NCALLS && + while (i < NCALLS && (j = ThreadLocalRandom.current().nextInt(bound)) == f) { assertTrue(0 <= j && j < bound); ++i; @@ -154,10 +156,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) { @@ -166,7 +167,7 @@ public class ThreadLocalRandomTest exten assertTrue(least <= f && f < bound); int i = 0; int j; - while (i < NCALLS && + while (i < NCALLS && (j = ThreadLocalRandom.current().nextInt(least, bound)) == f) { assertTrue(least <= j && j < bound); ++i; @@ -177,28 +178,28 @@ public class ThreadLocalRandomTest exten } /** - * nextLong(negative) throws IllegalArgumentException; + * nextLong(negative) throws IllegalArgumentException */ public void testNextLongBoundedNeg() { try { - long f = ThreadLocalRandom.current().nextLong(-17); - } catch(IllegalArgumentException success) { - } + long f = ThreadLocalRandom.current().nextLong(-17); + 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 f = ThreadLocalRandom.current().nextLong(17, 2); + 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) { @@ -206,7 +207,7 @@ public class ThreadLocalRandomTest exten assertTrue(0 <= f && f < bound); int i = 0; long j; - while (i < NCALLS && + while (i < NCALLS && (j = ThreadLocalRandom.current().nextLong(bound)) == f) { assertTrue(0 <= j && j < bound); ++i; @@ -217,7 +218,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) { @@ -226,7 +227,7 @@ public class ThreadLocalRandomTest exten assertTrue(least <= f && f < bound); int i = 0; long j; - while (i < NCALLS && + while (i < NCALLS && (j = ThreadLocalRandom.current().nextLong(least, bound)) == f) { assertTrue(least <= j && j < bound); ++i; @@ -236,10 +237,9 @@ public class ThreadLocalRandomTest exten } } - /** * 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) { @@ -248,7 +248,7 @@ public class ThreadLocalRandomTest exten assertTrue(least <= f && f < bound); int i = 0; double j; - while (i < NCALLS && + while (i < NCALLS && (j = ThreadLocalRandom.current().nextDouble(least, bound)) == f) { assertTrue(least <= j && j < bound); ++i; @@ -258,5 +258,41 @@ 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(); + + long firstRand = 0; + ThreadLocalRandom firstThreadLocalRandom = null; + + final CheckedRunnable getRandomState = new CheckedRunnable() { + public void realRun() { + ThreadLocalRandom current = ThreadLocalRandom.current(); + assertSame(current, ThreadLocalRandom.current()); + // test bug: the following is not guaranteed and not true in JDK8 + // assertNotSame(current, threadLocalRandom.get()); + rand.set(current.nextLong()); + threadLocalRandom.set(current); + }}; + + Thread first = newStartedThread(getRandomState); + awaitTermination(first); + firstRand = rand.get(); + firstThreadLocalRandom = threadLocalRandom.get(); + + for (int i = 0; i < NCALLS; i++) { + Thread t = newStartedThread(getRandomState); + awaitTermination(t); + if (firstRand != rand.get()) + return; + } + fail("all threads generate the same pseudo-random sequence"); + } }