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

Comparing jsr166/src/test/tck/SplittableRandomTest.java (file contents):
Revision 1.8 by jsr166, Tue Sep 24 06:17:12 2013 UTC vs.
Revision 1.20 by jsr166, Sun Nov 13 03:36:50 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.SplittableRandom;
8   import java.util.concurrent.atomic.AtomicInteger;
10 – import java.util.concurrent.atomic.AtomicLong;
9   import java.util.concurrent.atomic.LongAdder;
10  
11 + import junit.framework.Test;
12 + import junit.framework.TestSuite;
13 +
14   public class SplittableRandomTest 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(SplittableRandomTest.class);
# Line 39 | Line 40 | public class SplittableRandomTest extend
40      static final int NCALLS = 10000;
41  
42      // max sampled int bound
43 <    static final int MAX_INT_BOUND = (1 << 28);
43 >    static final int MAX_INT_BOUND = (1 << 26);
44  
45      // max sampled long bound
46 <    static final long MAX_LONG_BOUND = (1L << 42);
46 >    static final long MAX_LONG_BOUND = (1L << 40);
47  
48      // Number of replications for other checks
49      static final int REPS =
50          Integer.getInteger("SplittableRandomTest.reps", 4);
51  
52      /**
53 +     * Repeated calls to next (only accessible via reflection) produce
54 +     * at least two distinct results, and repeated calls produce all
55 +     * possible values.
56 +     */
57 +    public void testNext() throws ReflectiveOperationException {
58 +        SplittableRandom rnd = new SplittableRandom();
59 +        try {
60 +            java.lang.reflect.Method m
61 +                = SplittableRandom.class.getDeclaredMethod(
62 +                    "next", new Class[] { int.class });
63 +            m.setAccessible(true);
64 +
65 +            int i;
66 +            {
67 +                int val = new java.util.Random().nextInt(4);
68 +                for (i = 0; i < NCALLS; i++) {
69 +                    int q = (int) m.invoke(rnd, new Object[] { 2 });
70 +                    if (val == q) break;
71 +                }
72 +                assertTrue(i < NCALLS);
73 +            }
74 +
75 +            {
76 +                int r = (int) m.invoke(rnd, new Object[] { 3 });
77 +                for (i = 0; i < NCALLS; i++) {
78 +                    int q = (int) m.invoke(rnd, new Object[] { 3 });
79 +                    assertTrue(q < (1<<3));
80 +                    if (r != q) break;
81 +                }
82 +                assertTrue(i < NCALLS);
83 +            }
84 +        } catch (SecurityException acceptable) {}
85 +    }
86 +
87 +    /**
88       * Repeated calls to nextInt produce at least two distinct results
89       */
90      public void testNextInt() {
# Line 89 | Line 125 | public class SplittableRandomTest extend
125       * same values for nextLong.
126       */
127      public void testSeedConstructor() {
128 <        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863)  {
128 >        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863) {
129              SplittableRandom sr1 = new SplittableRandom(seed);
130              SplittableRandom sr2 = new SplittableRandom(seed);
131              for (int i = 0; i < REPS; ++i)
# Line 128 | Line 164 | public class SplittableRandomTest extend
164      }
165  
166      /**
167 <     * nextInt(negative) throws IllegalArgumentException
167 >     * nextInt(non-positive) throws IllegalArgumentException
168       */
169 <    public void testNextIntBoundedNeg() {
169 >    public void testNextIntBoundNonPositive() {
170          SplittableRandom sr = new SplittableRandom();
171 <        try {
172 <            int f = sr.nextInt(-17);
173 <            shouldThrow();
174 <        } catch (IllegalArgumentException success) {}
171 >        Runnable[] throwingActions = {
172 >            () -> sr.nextInt(-17),
173 >            () -> sr.nextInt(0),
174 >            () -> sr.nextInt(Integer.MIN_VALUE),
175 >        };
176 >        assertThrows(IllegalArgumentException.class, throwingActions);
177      }
178  
179      /**
# Line 143 | Line 181 | public class SplittableRandomTest extend
181       */
182      public void testNextIntBadBounds() {
183          SplittableRandom sr = new SplittableRandom();
184 <        try {
185 <            int f = sr.nextInt(17, 2);
186 <            shouldThrow();
187 <        } catch (IllegalArgumentException success) {}
184 >        Runnable[] throwingActions = {
185 >            () -> sr.nextInt(17, 2),
186 >            () -> sr.nextInt(-42, -42),
187 >            () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
188 >        };
189 >        assertThrows(IllegalArgumentException.class, throwingActions);
190      }
191  
192      /**
# Line 155 | Line 195 | public class SplittableRandomTest extend
195       */
196      public void testNextIntBounded() {
197          SplittableRandom sr = new SplittableRandom();
198 +        for (int i = 0; i < 2; i++) assertEquals(0, sr.nextInt(1));
199          // sample bound space across prime number increments
200          for (int bound = 2; bound < MAX_INT_BOUND; bound += 524959) {
201              int f = sr.nextInt(bound);
# Line 193 | Line 234 | public class SplittableRandomTest extend
234      }
235  
236      /**
237 <     * nextLong(negative) throws IllegalArgumentException
237 >     * nextLong(non-positive) throws IllegalArgumentException
238       */
239 <    public void testNextLongBoundedNeg() {
239 >    public void testNextLongBoundNonPositive() {
240          SplittableRandom sr = new SplittableRandom();
241 <        try {
242 <            long f = sr.nextLong(-17);
243 <            shouldThrow();
244 <        } catch (IllegalArgumentException success) {}
241 >        Runnable[] throwingActions = {
242 >            () -> sr.nextLong(-17L),
243 >            () -> sr.nextLong(0L),
244 >            () -> sr.nextLong(Long.MIN_VALUE),
245 >        };
246 >        assertThrows(IllegalArgumentException.class, throwingActions);
247      }
248  
249      /**
# Line 208 | Line 251 | public class SplittableRandomTest extend
251       */
252      public void testNextLongBadBounds() {
253          SplittableRandom sr = new SplittableRandom();
254 <        try {
255 <            long f = sr.nextLong(17, 2);
256 <            shouldThrow();
257 <        } catch (IllegalArgumentException success) {}
254 >        Runnable[] throwingActions = {
255 >            () -> sr.nextLong(17L, 2L),
256 >            () -> sr.nextLong(-42L, -42L),
257 >            () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
258 >        };
259 >        assertThrows(IllegalArgumentException.class, throwingActions);
260      }
261  
262      /**
# Line 220 | Line 265 | public class SplittableRandomTest extend
265       */
266      public void testNextLongBounded() {
267          SplittableRandom sr = new SplittableRandom();
268 +        for (int i = 0; i < 2; i++) assertEquals(0L, sr.nextLong(1L));
269          for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) {
270              long f = sr.nextLong(bound);
271              assertTrue(0 <= f && f < bound);
# Line 257 | Line 303 | public class SplittableRandomTest extend
303      }
304  
305      /**
306 +     * nextDouble(non-positive) throws IllegalArgumentException
307 +     */
308 +    public void testNextDoubleBoundNonPositive() {
309 +        SplittableRandom sr = new SplittableRandom();
310 +        Runnable[] throwingActions = {
311 +            () -> sr.nextDouble(-17.0d),
312 +            () -> sr.nextDouble(0.0d),
313 +            () -> sr.nextDouble(-Double.MIN_VALUE),
314 +            () -> sr.nextDouble(Double.NEGATIVE_INFINITY),
315 +            () -> sr.nextDouble(Double.NaN),
316 +        };
317 +        assertThrows(IllegalArgumentException.class, throwingActions);
318 +    }
319 +
320 +    /**
321 +     * nextDouble(! (least < bound)) throws IllegalArgumentException
322 +     */
323 +    public void testNextDoubleBadBounds() {
324 +        SplittableRandom sr = new SplittableRandom();
325 +        Runnable[] throwingActions = {
326 +            () -> sr.nextDouble(17.0d, 2.0d),
327 +            () -> sr.nextDouble(-42.0d, -42.0d),
328 +            () -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
329 +            () -> sr.nextDouble(Double.NaN, 0.0d),
330 +            () -> sr.nextDouble(0.0d, Double.NaN),
331 +        };
332 +        assertThrows(IllegalArgumentException.class, throwingActions);
333 +    }
334 +
335 +    // TODO: Test infinite bounds!
336 +    //() -> sr.nextDouble(Double.NEGATIVE_INFINITY, 0.0d),
337 +    //() -> sr.nextDouble(0.0d, Double.POSITIVE_INFINITY),
338 +
339 +    /**
340       * nextDouble(least, bound) returns least <= value < bound;
341       * repeated calls produce at least two distinct results
342       */
# Line 367 | Line 447 | public class SplittableRandomTest extend
447          for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) {
448              for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) {
449                  final int lo = least, hi = bound;
450 <                r.ints(size, lo, hi).parallel().
451 <                    forEach(x -> {if (x < lo || x >= hi)
452 <                                fails.getAndIncrement(); });
450 >                r.ints(size, lo, hi).parallel().forEach(
451 >                    x -> {
452 >                        if (x < lo || x >= hi)
453 >                            fails.getAndIncrement(); });
454              }
455          }
456          assertEquals(0, fails.get());
# Line 385 | Line 466 | public class SplittableRandomTest extend
466          for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) {
467              for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) {
468                  final long lo = least, hi = bound;
469 <                r.longs(size, lo, hi).parallel().
470 <                    forEach(x -> {if (x < lo || x >= hi)
471 <                                fails.getAndIncrement(); });
469 >                r.longs(size, lo, hi).parallel().forEach(
470 >                    x -> {
471 >                        if (x < lo || x >= hi)
472 >                            fails.getAndIncrement(); });
473              }
474          }
475          assertEquals(0, fails.get());
# Line 403 | Line 485 | public class SplittableRandomTest extend
485          for (double least = 0.00011; least < 1.0e20; least *= 9) {
486              for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) {
487                  final double lo = least, hi = bound;
488 <                r.doubles(size, lo, hi).parallel().
489 <                    forEach(x -> {if (x < lo || x >= hi)
490 <                                fails.getAndIncrement(); });
488 >                r.doubles(size, lo, hi).parallel().forEach(
489 >                    x -> {
490 >                        if (x < lo || x >= hi)
491 >                            fails.getAndIncrement(); });
492              }
493          }
494          assertEquals(0, fails.get());

Diff Legend

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