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.16 by jsr166, Fri Aug 16 07:07:01 2013 UTC vs.
Revision 1.23 by jsr166, Fri Dec 9 06:56:30 2016 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;
10 – import java.util.concurrent.atomic.AtomicInteger;
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 51 | 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 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
61 +        final java.lang.reflect.Method m;
62 +        try {
63 +            m = ThreadLocalRandom.class.getDeclaredMethod(
64 +                    "next", new Class[] { int.class });
65 +            m.setAccessible(true);
66 +        } catch (SecurityException
67 +                 | java.lang.reflect.InaccessibleObjectException acceptable) {
68 +            // Either jdk9 module system or security manager might deny access.
69 +            return;
70 +        }
71 +
72 +        int i;
73 +        {
74 +            int val = new java.util.Random().nextInt(4);
75 +            for (i = 0; i < NCALLS; i++) {
76 +                int q = (int) m.invoke(rnd, new Object[] { 2 });
77 +                if (val == q) break;
78 +            }
79 +            assertTrue(i < NCALLS);
80 +        }
81 +
82 +        {
83 +            int r = (int) m.invoke(rnd, new Object[] { 3 });
84 +            for (i = 0; i < NCALLS; i++) {
85 +                int q = (int) m.invoke(rnd, new Object[] { 3 });
86 +                assertTrue(q < (1<<3));
87 +                if (r != q) break;
88 +            }
89 +            assertTrue(i < NCALLS);
90 +        }
91 +    }
92 +
93 +    /**
94       * Repeated calls to nextInt produce at least two distinct results
95       */
96      public void testNextInt() {
# Line 117 | Line 157 | public class ThreadLocalRandomTest exten
157      }
158  
159      /**
160 <     * nextInt(negative) throws IllegalArgumentException
160 >     * nextInt(non-positive) throws IllegalArgumentException
161       */
162 <    public void testNextIntBoundedNeg() {
163 <        try {
164 <            int f = ThreadLocalRandom.current().nextInt(-17);
165 <            shouldThrow();
166 <        } catch (IllegalArgumentException success) {}
162 >    public void testNextIntBoundNonPositive() {
163 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
164 >        for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
165 >            try {
166 >                rnd.nextInt(bound);
167 >                shouldThrow();
168 >            } catch (IllegalArgumentException success) {}
169 >        }
170      }
171  
172      /**
173       * nextInt(least >= bound) throws IllegalArgumentException
174       */
175      public void testNextIntBadBounds() {
176 <        try {
177 <            int f = ThreadLocalRandom.current().nextInt(17, 2);
178 <            shouldThrow();
179 <        } catch (IllegalArgumentException success) {}
176 >        int[][] badBoundss = {
177 >            { 17, 2 },
178 >            { -42, -42 },
179 >            { Integer.MAX_VALUE, Integer.MIN_VALUE },
180 >        };
181 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
182 >        for (int[] badBounds : badBoundss) {
183 >            try {
184 >                rnd.nextInt(badBounds[0], badBounds[1]);
185 >                shouldThrow();
186 >            } catch (IllegalArgumentException success) {}
187 >        }
188      }
189  
190      /**
# Line 178 | Line 229 | public class ThreadLocalRandomTest exten
229      }
230  
231      /**
232 <     * nextLong(negative) throws IllegalArgumentException
232 >     * nextLong(non-positive) throws IllegalArgumentException
233       */
234 <    public void testNextLongBoundedNeg() {
235 <        try {
236 <            long f = ThreadLocalRandom.current().nextLong(-17);
237 <            shouldThrow();
238 <        } catch (IllegalArgumentException success) {}
234 >    public void testNextLongBoundNonPositive() {
235 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
236 >        for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
237 >            try {
238 >                rnd.nextLong(bound);
239 >                shouldThrow();
240 >            } catch (IllegalArgumentException success) {}
241 >        }
242      }
243  
244      /**
245       * nextLong(least >= bound) throws IllegalArgumentException
246       */
247      public void testNextLongBadBounds() {
248 <        try {
249 <            long f = ThreadLocalRandom.current().nextLong(17, 2);
250 <            shouldThrow();
251 <        } catch (IllegalArgumentException success) {}
248 >        long[][] badBoundss = {
249 >            { 17L, 2L },
250 >            { -42L, -42L },
251 >            { Long.MAX_VALUE, Long.MIN_VALUE },
252 >        };
253 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
254 >        for (long[] badBounds : badBoundss) {
255 >            try {
256 >                rnd.nextLong(badBounds[0], badBounds[1]);
257 >                shouldThrow();
258 >            } catch (IllegalArgumentException success) {}
259 >        }
260      }
261  
262      /**
# Line 238 | Line 300 | public class ThreadLocalRandomTest exten
300      }
301  
302      /**
303 +     * nextDouble(non-positive) throws IllegalArgumentException
304 +     */
305 +    public void testNextDoubleBoundNonPositive() {
306 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
307 +        double[] badBounds = {
308 +            0.0d,
309 +            -17.0d,
310 +            -Double.MIN_VALUE,
311 +            Double.NEGATIVE_INFINITY,
312 +            Double.NaN,
313 +        };
314 +        for (double bound : badBounds) {
315 +            try {
316 +                rnd.nextDouble(bound);
317 +                shouldThrow();
318 +            } catch (IllegalArgumentException success) {}
319 +        }
320 +    }
321 +
322 +    /**
323       * nextDouble(least, bound) returns least <= value < bound;
324       * repeated calls produce at least two distinct results
325       */
# Line 271 | Line 353 | public class ThreadLocalRandomTest exten
353          long firstRand = 0;
354          ThreadLocalRandom firstThreadLocalRandom = null;
355  
356 <        final CheckedRunnable getRandomState = new CheckedRunnable() {
356 >        Runnable getRandomState = new CheckedRunnable() {
357              public void realRun() {
358                  ThreadLocalRandom current = ThreadLocalRandom.current();
359                  assertSame(current, ThreadLocalRandom.current());

Diff Legend

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