--- jsr166/src/test/tck/ThreadLocalRandomTest.java	2009/07/31 23:02:50	1.1
+++ jsr166/src/test/tck/ThreadLocalRandomTest.java	2011/06/03 21:36:55	1.11
@@ -1,32 +1,33 @@
 /*
  * 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;
 
 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.
      */
 
-    // 
+    //
     static final int NCALLS = 10000;
 
     // max sampled int bound
@@ -41,8 +42,8 @@ public class ThreadLocalRandomTest exten
     public void testSetSeed() {
         try {
             ThreadLocalRandom.current().setSeed(17);
-        } catch(UnsupportedOperationException success) {
-        }
+            shouldThrow();
+        } catch (UnsupportedOperationException success) {}
     }
 
     /**
@@ -67,7 +68,6 @@ public class ThreadLocalRandomTest exten
         assertTrue(i < NCALLS);
     }
 
-
     /**
      * Repeated calls to nextBoolean produce at least one different result
      */
@@ -112,15 +112,14 @@ public class ThreadLocalRandomTest exten
         assertTrue(i < NCALLS);
     }
 
-
     /**
      * 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) {}
     }
 
     /**
@@ -128,12 +127,11 @@ public class ThreadLocalRandomTest exten
      */
     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
@@ -145,7 +143,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,7 +152,6 @@ public class ThreadLocalRandomTest exten
         }
     }
 
-
     /**
      * nextInt(least, bound) returns least <= value < bound;
      * repeated calls produce at least one different result
@@ -166,7 +163,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;
@@ -181,9 +178,9 @@ public class ThreadLocalRandomTest exten
      */
     public void testNextLongBoundedNeg() {
         try {
-            long  f = ThreadLocalRandom.current().nextLong(-17);
-        } catch(IllegalArgumentException success) {
-        }
+            long f = ThreadLocalRandom.current().nextLong(-17);
+            shouldThrow();
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -191,9 +188,9 @@ public class ThreadLocalRandomTest exten
      */
     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) {}
     }
 
     /**
@@ -206,7 +203,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;
@@ -226,7 +223,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,7 +233,6 @@ public class ThreadLocalRandomTest exten
         }
     }
 
-
     /**
      * nextDouble(least, bound) returns least <= value < bound;
      * repeated calls produce at least one different result
@@ -248,7 +244,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 +254,40 @@ 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> 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());
+                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");
+    }
 
 }