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.14 by jsr166, Sun Jul 14 16:55:01 2013 UTC vs.
Revision 1.30 by jsr166, Wed Aug 12 17:39:43 2020 UTC

# Line 3 | Line 3
3   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6 < import junit.framework.*;
7 < import java.util.*;
6 >
7   import java.util.concurrent.ThreadLocalRandom;
8   import java.util.concurrent.atomic.AtomicLong;
9   import java.util.concurrent.atomic.AtomicReference;
10  
11 + import junit.framework.Test;
12 + import junit.framework.TestSuite;
13 +
14   public class ThreadLocalRandomTest extends JSR166TestCase {
15  
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run(suite());
17 >        main(suite(), args);
18      }
19      public static Test suite() {
20          return new TestSuite(ThreadLocalRandomTest.class);
# Line 36 | Line 38 | public class ThreadLocalRandomTest exten
38      // max sampled long bound
39      static final long MAX_LONG_BOUND = (1L << 42);
40  
41 +    // Number of replications for other checks
42 +    static final int REPS = 20;
43 +
44      /**
45       * setSeed throws UnsupportedOperationException
46       */
# Line 47 | Line 52 | public class ThreadLocalRandomTest exten
52      }
53  
54      /**
55 +     * Repeated calls to next (only accessible via reflection) produce
56 +     * at least two distinct results, and repeated calls produce all
57 +     * possible values.
58 +     */
59 +    public void testNext() throws ReflectiveOperationException {
60 +        // Inhibit "An illegal reflective access operation has occurred"
61 +        if (!testImplementationDetails) return;
62 +
63 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
64 +        final java.lang.reflect.Method m;
65 +        try {
66 +            m = ThreadLocalRandom.class.getDeclaredMethod("next", int.class);
67 +            m.setAccessible(true);
68 +        } catch (SecurityException acceptable) {
69 +            // Security manager may deny access
70 +            return;
71 +        } catch (Exception ex) {
72 +            // jdk9 module system may deny access
73 +            if (ex.getClass().getSimpleName()
74 +                .equals("InaccessibleObjectException"))
75 +                return;
76 +            throw ex;
77 +        }
78 +
79 +        int i;
80 +        {
81 +            int val = new java.util.Random().nextInt(4);
82 +            for (i = 0; i < NCALLS; i++) {
83 +                int q = (int) m.invoke(rnd, new Object[] { 2 });
84 +                if (val == q) break;
85 +            }
86 +            assertTrue(i < NCALLS);
87 +        }
88 +
89 +        {
90 +            int r = (int) m.invoke(rnd, new Object[] { 3 });
91 +            for (i = 0; i < NCALLS; i++) {
92 +                int q = (int) m.invoke(rnd, new Object[] { 3 });
93 +                assertTrue(q < (1<<3));
94 +                if (r != q) break;
95 +            }
96 +            assertTrue(i < NCALLS);
97 +        }
98 +    }
99 +
100 +    /**
101       * Repeated calls to nextInt produce at least two distinct results
102       */
103      public void testNextInt() {
# Line 113 | Line 164 | public class ThreadLocalRandomTest exten
164      }
165  
166      /**
167 <     * nextInt(negative) throws IllegalArgumentException
167 >     * nextInt(non-positive) throws IllegalArgumentException
168       */
169 <    public void testNextIntBoundedNeg() {
170 <        try {
171 <            int f = ThreadLocalRandom.current().nextInt(-17);
172 <            shouldThrow();
173 <        } catch (IllegalArgumentException success) {}
169 >    public void testNextIntBoundNonPositive() {
170 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
171 >        for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
172 >            try {
173 >                rnd.nextInt(bound);
174 >                shouldThrow();
175 >            } catch (IllegalArgumentException success) {}
176 >        }
177      }
178  
179      /**
180       * nextInt(least >= bound) throws IllegalArgumentException
181       */
182      public void testNextIntBadBounds() {
183 <        try {
184 <            int f = ThreadLocalRandom.current().nextInt(17, 2);
185 <            shouldThrow();
186 <        } catch (IllegalArgumentException success) {}
183 >        int[][] badBoundss = {
184 >            { 17, 2 },
185 >            { -42, -42 },
186 >            { Integer.MAX_VALUE, Integer.MIN_VALUE },
187 >        };
188 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
189 >        for (int[] badBounds : badBoundss) {
190 >            try {
191 >                rnd.nextInt(badBounds[0], badBounds[1]);
192 >                shouldThrow();
193 >            } catch (IllegalArgumentException success) {}
194 >        }
195      }
196  
197      /**
# Line 174 | Line 236 | public class ThreadLocalRandomTest exten
236      }
237  
238      /**
239 <     * nextLong(negative) throws IllegalArgumentException
239 >     * nextLong(non-positive) throws IllegalArgumentException
240       */
241 <    public void testNextLongBoundedNeg() {
242 <        try {
243 <            long f = ThreadLocalRandom.current().nextLong(-17);
244 <            shouldThrow();
245 <        } catch (IllegalArgumentException success) {}
241 >    public void testNextLongBoundNonPositive() {
242 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
243 >        for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
244 >            try {
245 >                rnd.nextLong(bound);
246 >                shouldThrow();
247 >            } catch (IllegalArgumentException success) {}
248 >        }
249      }
250  
251      /**
252       * nextLong(least >= bound) throws IllegalArgumentException
253       */
254      public void testNextLongBadBounds() {
255 <        try {
256 <            long f = ThreadLocalRandom.current().nextLong(17, 2);
257 <            shouldThrow();
258 <        } catch (IllegalArgumentException success) {}
255 >        long[][] badBoundss = {
256 >            { 17L, 2L },
257 >            { -42L, -42L },
258 >            { Long.MAX_VALUE, Long.MIN_VALUE },
259 >        };
260 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
261 >        for (long[] badBounds : badBoundss) {
262 >            try {
263 >                rnd.nextLong(badBounds[0], badBounds[1]);
264 >                shouldThrow();
265 >            } catch (IllegalArgumentException success) {}
266 >        }
267      }
268  
269      /**
# Line 234 | Line 307 | public class ThreadLocalRandomTest exten
307      }
308  
309      /**
310 +     * nextDouble(non-positive) throws IllegalArgumentException
311 +     */
312 +    public void testNextDoubleBoundNonPositive() {
313 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
314 +        double[] badBounds = {
315 +            0.0d,
316 +            -17.0d,
317 +            -Double.MIN_VALUE,
318 +            Double.NEGATIVE_INFINITY,
319 +            Double.NaN,
320 +        };
321 +        for (double bound : badBounds) {
322 +            try {
323 +                rnd.nextDouble(bound);
324 +                shouldThrow();
325 +            } catch (IllegalArgumentException success) {}
326 +        }
327 +    }
328 +
329 +    /**
330       * nextDouble(least, bound) returns least <= value < bound;
331       * repeated calls produce at least two distinct results
332       */
# Line 261 | Line 354 | public class ThreadLocalRandomTest exten
354          // Don't use main thread's ThreadLocalRandom - it is likely to
355          // be polluted by previous tests.
356          final AtomicReference<ThreadLocalRandom> threadLocalRandom =
357 <            new AtomicReference<ThreadLocalRandom>();
357 >            new AtomicReference<>();
358          final AtomicLong rand = new AtomicLong();
359  
360 <        long firstRand = 0;
268 <        ThreadLocalRandom firstThreadLocalRandom = null;
269 <
270 <        final CheckedRunnable getRandomState = new CheckedRunnable() {
360 >        Runnable getRandomState = new CheckedRunnable() {
361              public void realRun() {
362                  ThreadLocalRandom current = ThreadLocalRandom.current();
363                  assertSame(current, ThreadLocalRandom.current());
274 –                // test bug: the following is not guaranteed and not true in JDK8
275 –                //                assertNotSame(current, threadLocalRandom.get());
364                  rand.set(current.nextLong());
365                  threadLocalRandom.set(current);
366              }};
367  
368 <        Thread first = newStartedThread(getRandomState);
369 <        awaitTermination(first);
370 <        firstRand = rand.get();
371 <        firstThreadLocalRandom = threadLocalRandom.get();
368 >        awaitTermination(newStartedThread(getRandomState));
369 >        long firstRand = rand.get();
370 >        ThreadLocalRandom firstThreadLocalRandom = threadLocalRandom.get();
371 >        assertNotNull(firstThreadLocalRandom);
372  
373          for (int i = 0; i < NCALLS; i++) {
374 <            Thread t = newStartedThread(getRandomState);
375 <            awaitTermination(t);
374 >            awaitTermination(newStartedThread(getRandomState));
375 >            if (testImplementationDetails)
376 >                // ThreadLocalRandom has been a singleton since jdk8.
377 >                assertSame(firstThreadLocalRandom, threadLocalRandom.get());
378              if (firstRand != rand.get())
379                  return;
380          }
381          fail("all threads generate the same pseudo-random sequence");
382      }
383  
384 +    /**
385 +     * Repeated calls to nextBytes produce at least values of different signs for every byte
386 +     */
387 +    public void testNextBytes() {
388 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
389 +        int n = rnd.nextInt(1, 20);
390 +        byte[] bytes = new byte[n];
391 +        outer:
392 +        for (int i = 0; i < n; i++) {
393 +            for (int tries = NCALLS; tries-->0; ) {
394 +                byte before = bytes[i];
395 +                rnd.nextBytes(bytes);
396 +                byte after = bytes[i];
397 +                if (after * before < 0)
398 +                    continue outer;
399 +            }
400 +            fail("not enough variation in random bytes");
401 +        }
402 +    }
403 +
404 +    /**
405 +     * Filling an empty array with random bytes succeeds without effect.
406 +     */
407 +    public void testNextBytes_emptyArray() {
408 +        ThreadLocalRandom.current().nextBytes(new byte[0]);
409 +    }
410 +
411 +    public void testNextBytes_nullArray() {
412 +        try {
413 +            ThreadLocalRandom.current().nextBytes(null);
414 +            shouldThrow();
415 +        } catch (NullPointerException success) {}
416 +    }
417 +
418   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines