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.15 by jsr166, Wed Dec 31 16:44:02 2014 UTC

# Line 7 | Line 7 | import junit.framework.*;
7   import java.util.*;
8   import java.util.SplittableRandom;
9   import java.util.concurrent.atomic.AtomicInteger;
10 – import java.util.concurrent.atomic.AtomicLong;
10   import java.util.concurrent.atomic.LongAdder;
11  
12   public class SplittableRandomTest extends JSR166TestCase {
# Line 39 | Line 38 | public class SplittableRandomTest extend
38      static final int NCALLS = 10000;
39  
40      // max sampled int bound
41 <    static final int MAX_INT_BOUND = (1 << 28);
41 >    static final int MAX_INT_BOUND = (1 << 26);
42  
43      // max sampled long bound
44 <    static final long MAX_LONG_BOUND = (1L << 42);
44 >    static final long MAX_LONG_BOUND = (1L << 40);
45  
46      // Number of replications for other checks
47      static final int REPS =
# Line 89 | Line 88 | public class SplittableRandomTest extend
88       * same values for nextLong.
89       */
90      public void testSeedConstructor() {
91 <        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863)  {
91 >        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863) {
92              SplittableRandom sr1 = new SplittableRandom(seed);
93              SplittableRandom sr2 = new SplittableRandom(seed);
94              for (int i = 0; i < REPS; ++i)
# Line 130 | Line 129 | public class SplittableRandomTest extend
129      /**
130       * nextInt(non-positive) throws IllegalArgumentException
131       */
132 <    public void testNextIntNonPositive() {
132 >    public void testNextIntBoundNonPositive() {
133          SplittableRandom sr = new SplittableRandom();
134          Runnable[] throwingActions = {
135              () -> sr.nextInt(-17),
# Line 145 | Line 144 | public class SplittableRandomTest extend
144       */
145      public void testNextIntBadBounds() {
146          SplittableRandom sr = new SplittableRandom();
147 <        try {
148 <            int f = sr.nextInt(17, 2);
149 <            shouldThrow();
150 <        } catch (IllegalArgumentException success) {}
147 >        Runnable[] throwingActions = {
148 >            () -> sr.nextInt(17, 2),
149 >            () -> sr.nextInt(-42, -42),
150 >            () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
151 >        };
152 >        assertThrows(IllegalArgumentException.class, throwingActions);
153      }
154  
155      /**
# Line 197 | Line 198 | public class SplittableRandomTest extend
198      /**
199       * nextLong(non-positive) throws IllegalArgumentException
200       */
201 <    public void testNextLongNonPositive() {
201 >    public void testNextLongBoundNonPositive() {
202          SplittableRandom sr = new SplittableRandom();
203          Runnable[] throwingActions = {
204              () -> sr.nextLong(-17L),
# Line 212 | Line 213 | public class SplittableRandomTest extend
213       */
214      public void testNextLongBadBounds() {
215          SplittableRandom sr = new SplittableRandom();
216 <        try {
217 <            long f = sr.nextLong(17, 2);
218 <            shouldThrow();
219 <        } catch (IllegalArgumentException success) {}
216 >        Runnable[] throwingActions = {
217 >            () -> sr.nextLong(17L, 2L),
218 >            () -> sr.nextLong(-42L, -42L),
219 >            () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
220 >        };
221 >        assertThrows(IllegalArgumentException.class, throwingActions);
222      }
223  
224      /**
# Line 263 | Line 266 | public class SplittableRandomTest extend
266      /**
267       * nextDouble(non-positive) throws IllegalArgumentException
268       */
269 <    public void testNextDoubleNonPositive() {
269 >    public void testNextDoubleBoundNonPositive() {
270          SplittableRandom sr = new SplittableRandom();
271          Runnable[] throwingActions = {
272              () -> sr.nextDouble(-17.0d),
# Line 276 | Line 279 | public class SplittableRandomTest extend
279      }
280  
281      /**
282 +     * nextDouble(! (least < bound)) throws IllegalArgumentException
283 +     */
284 +    public void testNextDoubleBadBounds() {
285 +        SplittableRandom sr = new SplittableRandom();
286 +        Runnable[] throwingActions = {
287 +            () -> sr.nextDouble(17.0d, 2.0d),
288 +            () -> sr.nextDouble(-42.0d, -42.0d),
289 +            () -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
290 +            () -> sr.nextDouble(Double.NaN, 0.0d),
291 +            () -> sr.nextDouble(0.0d, Double.NaN),
292 +        };
293 +        assertThrows(IllegalArgumentException.class, throwingActions);
294 +    }
295 +
296 +    // TODO: Test infinite bounds!
297 +    //() -> sr.nextDouble(Double.NEGATIVE_INFINITY, 0.0d),
298 +    //() -> sr.nextDouble(0.0d, Double.POSITIVE_INFINITY),
299 +
300 +    /**
301       * nextDouble(least, bound) returns least <= value < bound;
302       * repeated calls produce at least two distinct results
303       */

Diff Legend

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