--- jsr166/src/test/tck/ThreadLocalRandomTest.java	2009/11/21 02:07:27	1.4
+++ jsr166/src/test/tck/ThreadLocalRandomTest.java	2011/06/03 21:36:55	1.11
@@ -1,17 +1,18 @@
 /*
  * 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);
@@ -42,8 +43,7 @@ public class ThreadLocalRandomTest exten
         try {
             ThreadLocalRandom.current().setSeed(17);
             shouldThrow();
-        } catch (UnsupportedOperationException success) {
-        }
+        } catch (UnsupportedOperationException success) {}
     }
 
     /**
@@ -68,7 +68,6 @@ public class ThreadLocalRandomTest exten
         assertTrue(i < NCALLS);
     }
 
-
     /**
      * Repeated calls to nextBoolean produce at least one different result
      */
@@ -113,16 +112,14 @@ public class ThreadLocalRandomTest exten
         assertTrue(i < NCALLS);
     }
 
-
     /**
      * nextInt(negative) throws IllegalArgumentException;
      */
     public void testNextIntBoundedNeg() {
         try {
-            int  f = ThreadLocalRandom.current().nextInt(-17);
+            int f = ThreadLocalRandom.current().nextInt(-17);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -130,13 +127,11 @@ public class ThreadLocalRandomTest exten
      */
     public void testNextIntBadBounds() {
         try {
-            int  f = ThreadLocalRandom.current().nextInt(17, 2);
+            int f = ThreadLocalRandom.current().nextInt(17, 2);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
-
     /**
      * nextInt(bound) returns 0 <= value < bound;
      * repeated calls produce at least one different result
@@ -157,7 +152,6 @@ public class ThreadLocalRandomTest exten
         }
     }
 
-
     /**
      * nextInt(least, bound) returns least <= value < bound;
      * repeated calls produce at least one different result
@@ -184,10 +178,9 @@ public class ThreadLocalRandomTest exten
      */
     public void testNextLongBoundedNeg() {
         try {
-            long  f = ThreadLocalRandom.current().nextLong(-17);
+            long f = ThreadLocalRandom.current().nextLong(-17);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -195,10 +188,9 @@ public class ThreadLocalRandomTest exten
      */
     public void testNextLongBadBounds() {
         try {
-            long  f = ThreadLocalRandom.current().nextLong(17, 2);
+            long f = ThreadLocalRandom.current().nextLong(17, 2);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -241,7 +233,6 @@ public class ThreadLocalRandomTest exten
         }
     }
 
-
     /**
      * nextDouble(least, bound) returns least <= value < bound;
      * repeated calls produce at least one different result
@@ -263,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");
+    }
 
 }