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.4 by jsr166, Sun Jul 14 16:55:01 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 = 20;
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
# Line 88 | 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 127 | 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 142 | 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 154 | 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 192 | 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 207 | 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 219 | 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 256 | 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 283 | Line 364 | public class SplittableRandomTest extend
364       */
365      public void testBadStreamSize() {
366          SplittableRandom r = new SplittableRandom();
367 <        try {
368 <            java.util.stream.IntStream x = r.ints(-1L);
369 <            shouldThrow();
370 <        } catch (IllegalArgumentException success) {}
371 <        try {
372 <            java.util.stream.LongStream x = r.longs(-1L);
373 <            shouldThrow();
374 <        } catch (IllegalArgumentException success) {}
375 <        try {
295 <            java.util.stream.DoubleStream x = r.doubles(-1L);
296 <            shouldThrow();
297 <        } catch (IllegalArgumentException success) {}
367 >        Runnable[] throwingActions = {
368 >            () -> { java.util.stream.IntStream x = r.ints(-1L); },
369 >            () -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); },
370 >            () -> { java.util.stream.LongStream x = r.longs(-1L); },
371 >            () -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); },
372 >            () -> { java.util.stream.DoubleStream x = r.doubles(-1L); },
373 >            () -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); },
374 >        };
375 >        assertThrows(IllegalArgumentException.class, throwingActions);
376      }
377  
378      /**
# Line 303 | Line 381 | public class SplittableRandomTest extend
381       */
382      public void testBadStreamBounds() {
383          SplittableRandom r = new SplittableRandom();
384 <        try {
385 <            java.util.stream.IntStream x = r.ints(2, 1);
386 <            shouldThrow();
387 <        } catch (IllegalArgumentException success) {}
388 <        try {
389 <            java.util.stream.LongStream x = r.longs(1, -2);
390 <            shouldThrow();
391 <        } catch (IllegalArgumentException success) {}
392 <        try {
315 <            java.util.stream.DoubleStream x = r.doubles(0, 0);
316 <            shouldThrow();
317 <        } catch (IllegalArgumentException success) {}
384 >        Runnable[] throwingActions = {
385 >            () -> { java.util.stream.IntStream x = r.ints(2, 1); },
386 >            () -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
387 >            () -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
388 >            () -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
389 >            () -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
390 >            () -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
391 >        };
392 >        assertThrows(IllegalArgumentException.class, throwingActions);
393      }
394  
395      /**
# Line 326 | Line 401 | public class SplittableRandomTest extend
401          long size = 0;
402          for (int reps = 0; reps < REPS; ++reps) {
403              counter.reset();
404 <            r.ints(size).parallel().forEach(x -> {counter.increment();});
404 >            r.ints(size).parallel().forEach(x -> counter.increment());
405              assertEquals(size, counter.sum());
406              size += 524959;
407          }
# Line 341 | Line 416 | public class SplittableRandomTest extend
416          long size = 0;
417          for (int reps = 0; reps < REPS; ++reps) {
418              counter.reset();
419 <            r.longs(size).parallel().forEach(x -> {counter.increment();});
419 >            r.longs(size).parallel().forEach(x -> counter.increment());
420              assertEquals(size, counter.sum());
421              size += 524959;
422          }
# Line 356 | Line 431 | public class SplittableRandomTest extend
431          long size = 0;
432          for (int reps = 0; reps < REPS; ++reps) {
433              counter.reset();
434 <            r.doubles(size).parallel().forEach(x -> {counter.increment();});
434 >            r.doubles(size).parallel().forEach(x -> counter.increment());
435              assertEquals(size, counter.sum());
436              size += 524959;
437          }
# Line 372 | 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 390 | 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 408 | 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());
# Line 423 | Line 501 | public class SplittableRandomTest extend
501          LongAdder counter = new LongAdder();
502          SplittableRandom r = new SplittableRandom();
503          long size = 100;
504 <        r.ints().limit(size).parallel().forEach(x -> {counter.increment();});
504 >        r.ints().limit(size).parallel().forEach(x -> counter.increment());
505          assertEquals(size, counter.sum());
506      }
507  
# Line 434 | Line 512 | public class SplittableRandomTest extend
512          LongAdder counter = new LongAdder();
513          SplittableRandom r = new SplittableRandom();
514          long size = 100;
515 <        r.longs().limit(size).parallel().forEach(x -> {counter.increment();});
515 >        r.longs().limit(size).parallel().forEach(x -> counter.increment());
516          assertEquals(size, counter.sum());
517      }
518  
# Line 445 | Line 523 | public class SplittableRandomTest extend
523          LongAdder counter = new LongAdder();
524          SplittableRandom r = new SplittableRandom();
525          long size = 100;
526 <        r.doubles().limit(size).parallel().forEach(x -> {counter.increment();});
526 >        r.doubles().limit(size).parallel().forEach(x -> counter.increment());
527          assertEquals(size, counter.sum());
528      }
529  
# Line 456 | Line 534 | public class SplittableRandomTest extend
534          LongAdder counter = new LongAdder();
535          SplittableRandom r = new SplittableRandom();
536          long size = 100;
537 <        r.ints().limit(size).forEach(x -> {counter.increment();});
537 >        r.ints().limit(size).forEach(x -> counter.increment());
538          assertEquals(size, counter.sum());
539      }
540  
# Line 467 | Line 545 | public class SplittableRandomTest extend
545          LongAdder counter = new LongAdder();
546          SplittableRandom r = new SplittableRandom();
547          long size = 100;
548 <        r.longs().limit(size).forEach(x -> {counter.increment();});
548 >        r.longs().limit(size).forEach(x -> counter.increment());
549          assertEquals(size, counter.sum());
550      }
551  
# Line 478 | Line 556 | public class SplittableRandomTest extend
556          LongAdder counter = new LongAdder();
557          SplittableRandom r = new SplittableRandom();
558          long size = 100;
559 <        r.doubles().limit(size).forEach(x -> {counter.increment();});
559 >        r.doubles().limit(size).forEach(x -> counter.increment());
560          assertEquals(size, counter.sum());
561      }
562  

Diff Legend

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