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.9 by jsr166, Tue Sep 24 06:35:35 2013 UTC vs.
Revision 1.18 by jsr166, Sat Apr 25 04:55:31 2015 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 =
# Line 89 | Line 90 | public class SplittableRandomTest extend
90       * same values for nextLong.
91       */
92      public void testSeedConstructor() {
93 <        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863)  {
93 >        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863) {
94              SplittableRandom sr1 = new SplittableRandom(seed);
95              SplittableRandom sr2 = new SplittableRandom(seed);
96              for (int i = 0; i < REPS; ++i)
# Line 130 | Line 131 | public class SplittableRandomTest extend
131      /**
132       * nextInt(non-positive) throws IllegalArgumentException
133       */
134 <    public void testNextIntNonPositive() {
134 >    public void testNextIntBoundNonPositive() {
135          SplittableRandom sr = new SplittableRandom();
136          Runnable[] throwingActions = {
137              () -> sr.nextInt(-17),
# Line 145 | Line 146 | public class SplittableRandomTest extend
146       */
147      public void testNextIntBadBounds() {
148          SplittableRandom sr = new SplittableRandom();
149 <        try {
150 <            int f = sr.nextInt(17, 2);
151 <            shouldThrow();
152 <        } catch (IllegalArgumentException success) {}
149 >        Runnable[] throwingActions = {
150 >            () -> sr.nextInt(17, 2),
151 >            () -> sr.nextInt(-42, -42),
152 >            () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
153 >        };
154 >        assertThrows(IllegalArgumentException.class, throwingActions);
155      }
156  
157      /**
# Line 197 | Line 200 | public class SplittableRandomTest extend
200      /**
201       * nextLong(non-positive) throws IllegalArgumentException
202       */
203 <    public void testNextLongNonPositive() {
203 >    public void testNextLongBoundNonPositive() {
204          SplittableRandom sr = new SplittableRandom();
205          Runnable[] throwingActions = {
206              () -> sr.nextLong(-17L),
# Line 212 | Line 215 | public class SplittableRandomTest extend
215       */
216      public void testNextLongBadBounds() {
217          SplittableRandom sr = new SplittableRandom();
218 <        try {
219 <            long f = sr.nextLong(17, 2);
220 <            shouldThrow();
221 <        } catch (IllegalArgumentException success) {}
218 >        Runnable[] throwingActions = {
219 >            () -> sr.nextLong(17L, 2L),
220 >            () -> sr.nextLong(-42L, -42L),
221 >            () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
222 >        };
223 >        assertThrows(IllegalArgumentException.class, throwingActions);
224      }
225  
226      /**
# Line 263 | Line 268 | public class SplittableRandomTest extend
268      /**
269       * nextDouble(non-positive) throws IllegalArgumentException
270       */
271 <    public void testNextDoubleNonPositive() {
271 >    public void testNextDoubleBoundNonPositive() {
272          SplittableRandom sr = new SplittableRandom();
273          Runnable[] throwingActions = {
274              () -> sr.nextDouble(-17.0d),
# Line 276 | Line 281 | public class SplittableRandomTest extend
281      }
282  
283      /**
284 +     * nextDouble(! (least < bound)) throws IllegalArgumentException
285 +     */
286 +    public void testNextDoubleBadBounds() {
287 +        SplittableRandom sr = new SplittableRandom();
288 +        Runnable[] throwingActions = {
289 +            () -> sr.nextDouble(17.0d, 2.0d),
290 +            () -> sr.nextDouble(-42.0d, -42.0d),
291 +            () -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
292 +            () -> sr.nextDouble(Double.NaN, 0.0d),
293 +            () -> sr.nextDouble(0.0d, Double.NaN),
294 +        };
295 +        assertThrows(IllegalArgumentException.class, throwingActions);
296 +    }
297 +
298 +    // TODO: Test infinite bounds!
299 +    //() -> sr.nextDouble(Double.NEGATIVE_INFINITY, 0.0d),
300 +    //() -> sr.nextDouble(0.0d, Double.POSITIVE_INFINITY),
301 +
302 +    /**
303       * nextDouble(least, bound) returns least <= value < bound;
304       * repeated calls produce at least two distinct results
305       */
# Line 386 | Line 410 | public class SplittableRandomTest extend
410          for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) {
411              for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) {
412                  final int lo = least, hi = bound;
413 <                r.ints(size, lo, hi).parallel().
414 <                    forEach(x -> {if (x < lo || x >= hi)
415 <                                fails.getAndIncrement(); });
413 >                r.ints(size, lo, hi).parallel().forEach(
414 >                    x -> {
415 >                        if (x < lo || x >= hi)
416 >                            fails.getAndIncrement(); });
417              }
418          }
419          assertEquals(0, fails.get());
# Line 404 | Line 429 | public class SplittableRandomTest extend
429          for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) {
430              for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) {
431                  final long lo = least, hi = bound;
432 <                r.longs(size, lo, hi).parallel().
433 <                    forEach(x -> {if (x < lo || x >= hi)
434 <                                fails.getAndIncrement(); });
432 >                r.longs(size, lo, hi).parallel().forEach(
433 >                    x -> {
434 >                        if (x < lo || x >= hi)
435 >                            fails.getAndIncrement(); });
436              }
437          }
438          assertEquals(0, fails.get());
# Line 422 | Line 448 | public class SplittableRandomTest extend
448          for (double least = 0.00011; least < 1.0e20; least *= 9) {
449              for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) {
450                  final double lo = least, hi = bound;
451 <                r.doubles(size, lo, hi).parallel().
452 <                    forEach(x -> {if (x < lo || x >= hi)
453 <                                fails.getAndIncrement(); });
451 >                r.doubles(size, lo, hi).parallel().forEach(
452 >                    x -> {
453 >                        if (x < lo || x >= hi)
454 >                            fails.getAndIncrement(); });
455              }
456          }
457          assertEquals(0, fails.get());

Diff Legend

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