| /* |
| * 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/publicdomain/zero/1.0/ |
| */ |
| |
| package jsr166; |
| |
| import junit.framework.*; |
| import java.util.*; |
| import java.util.concurrent.ThreadLocalRandom; |
| import java.util.concurrent.atomic.AtomicLong; |
| import java.util.concurrent.atomic.AtomicReference; |
| |
| public class ThreadLocalRandomTest extends JSR166TestCase { |
| |
| /* |
| * 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. |
| */ |
| |
| // |
| static final int NCALLS = 10000; |
| |
| // max sampled int bound |
| static final int MAX_INT_BOUND = (1 << 28); |
| |
| // Max sampled long bound |
| static final long MAX_LONG_BOUND = (1L << 42); |
| |
| /** |
| * setSeed throws UnsupportedOperationException |
| */ |
| public void testSetSeed() { |
| try { |
| ThreadLocalRandom.current().setSeed(17); |
| shouldThrow(); |
| } catch (UnsupportedOperationException success) {} |
| } |
| |
| /** |
| * Repeated calls to nextInt produce at least one different result |
| */ |
| public void testNextInt() { |
| int f = ThreadLocalRandom.current().nextInt(); |
| int i = 0; |
| while (i < NCALLS && ThreadLocalRandom.current().nextInt() == f) |
| ++i; |
| assertTrue(i < NCALLS); |
| } |
| |
| /** |
| * Repeated calls to nextLong produce at least one different result |
| */ |
| public void testNextLong() { |
| long f = ThreadLocalRandom.current().nextLong(); |
| int i = 0; |
| while (i < NCALLS && ThreadLocalRandom.current().nextLong() == f) |
| ++i; |
| assertTrue(i < NCALLS); |
| } |
| |
| /** |
| * Repeated calls to nextBoolean produce at least one different result |
| */ |
| public void testNextBoolean() { |
| boolean f = ThreadLocalRandom.current().nextBoolean(); |
| int i = 0; |
| while (i < NCALLS && ThreadLocalRandom.current().nextBoolean() == f) |
| ++i; |
| assertTrue(i < NCALLS); |
| } |
| |
| /** |
| * Repeated calls to nextFloat produce at least one different result |
| */ |
| public void testNextFloat() { |
| float f = ThreadLocalRandom.current().nextFloat(); |
| int i = 0; |
| while (i < NCALLS && ThreadLocalRandom.current().nextFloat() == f) |
| ++i; |
| assertTrue(i < NCALLS); |
| } |
| |
| /** |
| * Repeated calls to nextDouble produce at least one different result |
| */ |
| public void testNextDouble() { |
| double f = ThreadLocalRandom.current().nextDouble(); |
| double i = 0; |
| while (i < NCALLS && ThreadLocalRandom.current().nextDouble() == f) |
| ++i; |
| assertTrue(i < NCALLS); |
| } |
| |
| /** |
| * Repeated calls to nextGaussian produce at least one different result |
| */ |
| public void testNextGaussian() { |
| double f = ThreadLocalRandom.current().nextGaussian(); |
| int i = 0; |
| while (i < NCALLS && ThreadLocalRandom.current().nextGaussian() == f) |
| ++i; |
| assertTrue(i < NCALLS); |
| } |
| |
| /** |
| * nextInt(negative) throws IllegalArgumentException; |
| */ |
| public void testNextIntBoundedNeg() { |
| try { |
| int f = ThreadLocalRandom.current().nextInt(-17); |
| shouldThrow(); |
| } catch (IllegalArgumentException success) {} |
| } |
| |
| /** |
| * nextInt(least >= bound) throws IllegalArgumentException; |
| */ |
| public void testNextIntBadBounds() { |
| try { |
| 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 |
| */ |
| public void testNextIntBounded() { |
| // sample bound space across prime number increments |
| for (int bound = 2; bound < MAX_INT_BOUND; bound += 524959) { |
| int f = ThreadLocalRandom.current().nextInt(bound); |
| assertTrue(0 <= f && f < bound); |
| int i = 0; |
| int j; |
| while (i < NCALLS && |
| (j = ThreadLocalRandom.current().nextInt(bound)) == f) { |
| assertTrue(0 <= j && j < bound); |
| ++i; |
| } |
| assertTrue(i < NCALLS); |
| } |
| } |
| |
| /** |
| * nextInt(least, bound) returns least <= value < bound; |
| * repeated calls produce at least one different result |
| */ |
| public void testNextIntBounded2() { |
| for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) { |
| for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 49979687) { |
| int f = ThreadLocalRandom.current().nextInt(least, bound); |
| assertTrue(least <= f && f < bound); |
| int i = 0; |
| int j; |
| while (i < NCALLS && |
| (j = ThreadLocalRandom.current().nextInt(least, bound)) == f) { |
| assertTrue(least <= j && j < bound); |
| ++i; |
| } |
| assertTrue(i < NCALLS); |
| } |
| } |
| } |
| |
| /** |
| * nextLong(negative) throws IllegalArgumentException; |
| */ |
| public void testNextLongBoundedNeg() { |
| try { |
| long f = ThreadLocalRandom.current().nextLong(-17); |
| shouldThrow(); |
| } catch (IllegalArgumentException success) {} |
| } |
| |
| /** |
| * nextLong(least >= bound) throws IllegalArgumentException; |
| */ |
| public void testNextLongBadBounds() { |
| try { |
| 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 |
| */ |
| public void testNextLongBounded() { |
| for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) { |
| long f = ThreadLocalRandom.current().nextLong(bound); |
| assertTrue(0 <= f && f < bound); |
| int i = 0; |
| long j; |
| while (i < NCALLS && |
| (j = ThreadLocalRandom.current().nextLong(bound)) == f) { |
| assertTrue(0 <= j && j < bound); |
| ++i; |
| } |
| assertTrue(i < NCALLS); |
| } |
| } |
| |
| /** |
| * nextLong(least, bound) returns least <= value < bound; |
| * repeated calls produce at least one different result |
| */ |
| public void testNextLongBounded2() { |
| for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) { |
| for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) { |
| long f = ThreadLocalRandom.current().nextLong(least, bound); |
| assertTrue(least <= f && f < bound); |
| int i = 0; |
| long j; |
| while (i < NCALLS && |
| (j = ThreadLocalRandom.current().nextLong(least, bound)) == f) { |
| assertTrue(least <= j && j < bound); |
| ++i; |
| } |
| assertTrue(i < NCALLS); |
| } |
| } |
| } |
| |
| /** |
| * nextDouble(least, bound) returns least <= value < bound; |
| * repeated calls produce at least one different result |
| */ |
| public void testNextDoubleBounded2() { |
| for (double least = 0.0001; least < 1.0e20; least *= 8) { |
| for (double bound = least * 1.001; bound < 1.0e20; bound *= 16) { |
| double f = ThreadLocalRandom.current().nextDouble(least, bound); |
| assertTrue(least <= f && f < bound); |
| int i = 0; |
| double j; |
| while (i < NCALLS && |
| (j = ThreadLocalRandom.current().nextDouble(least, bound)) == f) { |
| assertTrue(least <= j && j < bound); |
| ++i; |
| } |
| assertTrue(i < NCALLS); |
| } |
| } |
| } |
| |
| /** |
| * 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> threadLocalRandom = |
| new AtomicReference<ThreadLocalRandom>(); |
| 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"); |
| } |
| |
| } |