ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadLocalRandomTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ThreadLocalRandomTest.java (file contents):
Revision 1.9 by jsr166, Fri May 27 19:44:03 2011 UTC vs.
Revision 1.18 by jsr166, Wed Sep 25 07:39:17 2013 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6   import junit.framework.*;
7 import java.util.concurrent.*;
7   import java.util.*;
8 + import java.util.concurrent.ThreadLocalRandom;
9 + import java.util.concurrent.atomic.AtomicLong;
10 + import java.util.concurrent.atomic.AtomicReference;
11  
12   public class ThreadLocalRandomTest extends JSR166TestCase {
13  
# Line 16 | Line 18 | public class ThreadLocalRandomTest exten
18          return new TestSuite(ThreadLocalRandomTest.class);
19      }
20  
21 <    /**
21 >    /*
22       * Testing coverage notes:
23       *
24       * We don't test randomness properties, but only that repeated
# Line 25 | Line 27 | public class ThreadLocalRandomTest exten
27       * across multiples of primes.
28       */
29  
30 <    //
30 >    // max numbers of calls to detect getting stuck on one value
31      static final int NCALLS = 10000;
32  
33      // max sampled int bound
34      static final int MAX_INT_BOUND = (1 << 28);
35  
36 <    // Max sampled long bound
36 >    // max sampled long bound
37      static final long MAX_LONG_BOUND = (1L << 42);
38  
39 +    // Number of replications for other checks
40 +    static final int REPS = 20;
41 +
42      /**
43       * setSeed throws UnsupportedOperationException
44       */
# Line 45 | Line 50 | public class ThreadLocalRandomTest exten
50      }
51  
52      /**
53 <     * Repeated calls to nextInt produce at least one different result
53 >     * Repeated calls to nextInt produce at least two distinct results
54       */
55      public void testNextInt() {
56          int f = ThreadLocalRandom.current().nextInt();
# Line 56 | Line 61 | public class ThreadLocalRandomTest exten
61      }
62  
63      /**
64 <     * Repeated calls to nextLong produce at least one different result
64 >     * Repeated calls to nextLong produce at least two distinct results
65       */
66      public void testNextLong() {
67          long f = ThreadLocalRandom.current().nextLong();
# Line 67 | Line 72 | public class ThreadLocalRandomTest exten
72      }
73  
74      /**
75 <     * Repeated calls to nextBoolean produce at least one different result
75 >     * Repeated calls to nextBoolean produce at least two distinct results
76       */
77      public void testNextBoolean() {
78          boolean f = ThreadLocalRandom.current().nextBoolean();
# Line 78 | Line 83 | public class ThreadLocalRandomTest exten
83      }
84  
85      /**
86 <     * Repeated calls to nextFloat produce at least one different result
86 >     * Repeated calls to nextFloat produce at least two distinct results
87       */
88      public void testNextFloat() {
89          float f = ThreadLocalRandom.current().nextFloat();
# Line 89 | Line 94 | public class ThreadLocalRandomTest exten
94      }
95  
96      /**
97 <     * Repeated calls to nextDouble produce at least one different result
97 >     * Repeated calls to nextDouble produce at least two distinct results
98       */
99      public void testNextDouble() {
100          double f = ThreadLocalRandom.current().nextDouble();
101 <        double i = 0;
101 >        int i = 0;
102          while (i < NCALLS && ThreadLocalRandom.current().nextDouble() == f)
103              ++i;
104          assertTrue(i < NCALLS);
105      }
106  
107      /**
108 <     * Repeated calls to nextGaussian produce at least one different result
108 >     * Repeated calls to nextGaussian produce at least two distinct results
109       */
110      public void testNextGaussian() {
111          double f = ThreadLocalRandom.current().nextGaussian();
# Line 111 | Line 116 | public class ThreadLocalRandomTest exten
116      }
117  
118      /**
119 <     * nextInt(negative) throws IllegalArgumentException;
119 >     * nextInt(negative) throws IllegalArgumentException
120       */
121      public void testNextIntBoundedNeg() {
122          try {
# Line 121 | Line 126 | public class ThreadLocalRandomTest exten
126      }
127  
128      /**
129 <     * nextInt(least >= bound) throws IllegalArgumentException;
129 >     * nextInt(least >= bound) throws IllegalArgumentException
130       */
131      public void testNextIntBadBounds() {
132          try {
# Line 132 | Line 137 | public class ThreadLocalRandomTest exten
137  
138      /**
139       * nextInt(bound) returns 0 <= value < bound;
140 <     * repeated calls produce at least one different result
140 >     * repeated calls produce at least two distinct results
141       */
142      public void testNextIntBounded() {
143          // sample bound space across prime number increments
# Line 152 | Line 157 | public class ThreadLocalRandomTest exten
157  
158      /**
159       * nextInt(least, bound) returns least <= value < bound;
160 <     * repeated calls produce at least one different result
160 >     * repeated calls produce at least two distinct results
161       */
162      public void testNextIntBounded2() {
163          for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) {
# Line 172 | Line 177 | public class ThreadLocalRandomTest exten
177      }
178  
179      /**
180 <     * nextLong(negative) throws IllegalArgumentException;
180 >     * nextLong(negative) throws IllegalArgumentException
181       */
182      public void testNextLongBoundedNeg() {
183          try {
# Line 182 | Line 187 | public class ThreadLocalRandomTest exten
187      }
188  
189      /**
190 <     * nextLong(least >= bound) throws IllegalArgumentException;
190 >     * nextLong(least >= bound) throws IllegalArgumentException
191       */
192      public void testNextLongBadBounds() {
193          try {
# Line 193 | Line 198 | public class ThreadLocalRandomTest exten
198  
199      /**
200       * nextLong(bound) returns 0 <= value < bound;
201 <     * repeated calls produce at least one different result
201 >     * repeated calls produce at least two distinct results
202       */
203      public void testNextLongBounded() {
204          for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) {
# Line 212 | Line 217 | public class ThreadLocalRandomTest exten
217  
218      /**
219       * nextLong(least, bound) returns least <= value < bound;
220 <     * repeated calls produce at least one different result
220 >     * repeated calls produce at least two distinct results
221       */
222      public void testNextLongBounded2() {
223          for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) {
# Line 233 | Line 238 | public class ThreadLocalRandomTest exten
238  
239      /**
240       * nextDouble(least, bound) returns least <= value < bound;
241 <     * repeated calls produce at least one different result
241 >     * repeated calls produce at least two distinct results
242       */
243      public void testNextDoubleBounded2() {
244          for (double least = 0.0001; least < 1.0e20; least *= 8) {
# Line 252 | Line 257 | public class ThreadLocalRandomTest exten
257          }
258      }
259  
260 +    /**
261 +     * Different threads produce different pseudo-random sequences
262 +     */
263 +    public void testDifferentSequences() {
264 +        // Don't use main thread's ThreadLocalRandom - it is likely to
265 +        // be polluted by previous tests.
266 +        final AtomicReference<ThreadLocalRandom> threadLocalRandom =
267 +            new AtomicReference<ThreadLocalRandom>();
268 +        final AtomicLong rand = new AtomicLong();
269 +
270 +        long firstRand = 0;
271 +        ThreadLocalRandom firstThreadLocalRandom = null;
272 +
273 +        Runnable getRandomState = new CheckedRunnable() {
274 +            public void realRun() {
275 +                ThreadLocalRandom current = ThreadLocalRandom.current();
276 +                assertSame(current, ThreadLocalRandom.current());
277 +                // test bug: the following is not guaranteed and not true in JDK8
278 +                //                assertNotSame(current, threadLocalRandom.get());
279 +                rand.set(current.nextLong());
280 +                threadLocalRandom.set(current);
281 +            }};
282 +
283 +        Thread first = newStartedThread(getRandomState);
284 +        awaitTermination(first);
285 +        firstRand = rand.get();
286 +        firstThreadLocalRandom = threadLocalRandom.get();
287 +
288 +        for (int i = 0; i < NCALLS; i++) {
289 +            Thread t = newStartedThread(getRandomState);
290 +            awaitTermination(t);
291 +            if (firstRand != rand.get())
292 +                return;
293 +        }
294 +        fail("all threads generate the same pseudo-random sequence");
295 +    }
296 +
297   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines