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.7 by jsr166, Mon Sep 23 17:23:50 2013 UTC vs.
Revision 1.14 by jsr166, Sat Dec 21 21:32:34 2013 UTC

# Line 39 | Line 39 | public class SplittableRandomTest extend
39      static final int NCALLS = 10000;
40  
41      // max sampled int bound
42 <    static final int MAX_INT_BOUND = (1 << 28);
42 >    static final int MAX_INT_BOUND = (1 << 26);
43  
44      // max sampled long bound
45 <    static final long MAX_LONG_BOUND = (1L << 42);
45 >    static final long MAX_LONG_BOUND = (1L << 40);
46  
47      // Number of replications for other checks
48      static final int REPS =
# Line 89 | Line 89 | public class SplittableRandomTest extend
89       * same values for nextLong.
90       */
91      public void testSeedConstructor() {
92 <        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863)  {
92 >        for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863) {
93              SplittableRandom sr1 = new SplittableRandom(seed);
94              SplittableRandom sr2 = new SplittableRandom(seed);
95              for (int i = 0; i < REPS; ++i)
# Line 128 | Line 128 | public class SplittableRandomTest extend
128      }
129  
130      /**
131 <     * nextInt(negative) throws IllegalArgumentException
131 >     * nextInt(non-positive) throws IllegalArgumentException
132       */
133 <    public void testNextIntBoundedNeg() {
133 >    public void testNextIntBoundNonPositive() {
134          SplittableRandom sr = new SplittableRandom();
135 <        try {
136 <            int f = sr.nextInt(-17);
137 <            shouldThrow();
138 <        } catch (IllegalArgumentException success) {}
135 >        Runnable[] throwingActions = {
136 >            () -> sr.nextInt(-17),
137 >            () -> sr.nextInt(0),
138 >            () -> sr.nextInt(Integer.MIN_VALUE),
139 >        };
140 >        assertThrows(IllegalArgumentException.class, throwingActions);
141      }
142  
143      /**
# Line 143 | Line 145 | public class SplittableRandomTest extend
145       */
146      public void testNextIntBadBounds() {
147          SplittableRandom sr = new SplittableRandom();
148 <        try {
149 <            int f = sr.nextInt(17, 2);
150 <            shouldThrow();
151 <        } catch (IllegalArgumentException success) {}
148 >        Runnable[] throwingActions = {
149 >            () -> sr.nextInt(17, 2),
150 >            () -> sr.nextInt(-42, -42),
151 >            () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
152 >        };
153 >        assertThrows(IllegalArgumentException.class, throwingActions);
154      }
155  
156      /**
# Line 193 | Line 197 | public class SplittableRandomTest extend
197      }
198  
199      /**
200 <     * nextLong(negative) throws IllegalArgumentException
200 >     * nextLong(non-positive) throws IllegalArgumentException
201       */
202 <    public void testNextLongBoundedNeg() {
202 >    public void testNextLongBoundNonPositive() {
203          SplittableRandom sr = new SplittableRandom();
204 <        try {
205 <            long f = sr.nextLong(-17);
206 <            shouldThrow();
207 <        } catch (IllegalArgumentException success) {}
204 >        Runnable[] throwingActions = {
205 >            () -> sr.nextLong(-17L),
206 >            () -> sr.nextLong(0L),
207 >            () -> sr.nextLong(Long.MIN_VALUE),
208 >        };
209 >        assertThrows(IllegalArgumentException.class, throwingActions);
210      }
211  
212      /**
# Line 208 | Line 214 | public class SplittableRandomTest extend
214       */
215      public void testNextLongBadBounds() {
216          SplittableRandom sr = new SplittableRandom();
217 <        try {
218 <            long f = sr.nextLong(17, 2);
219 <            shouldThrow();
220 <        } catch (IllegalArgumentException success) {}
217 >        Runnable[] throwingActions = {
218 >            () -> sr.nextLong(17L, 2L),
219 >            () -> sr.nextLong(-42L, -42L),
220 >            () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
221 >        };
222 >        assertThrows(IllegalArgumentException.class, throwingActions);
223      }
224  
225      /**
# Line 257 | Line 265 | public class SplittableRandomTest extend
265      }
266  
267      /**
268 +     * nextDouble(non-positive) throws IllegalArgumentException
269 +     */
270 +    public void testNextDoubleBoundNonPositive() {
271 +        SplittableRandom sr = new SplittableRandom();
272 +        Runnable[] throwingActions = {
273 +            () -> sr.nextDouble(-17.0d),
274 +            () -> sr.nextDouble(0.0d),
275 +            () -> sr.nextDouble(-Double.MIN_VALUE),
276 +            () -> sr.nextDouble(Double.NEGATIVE_INFINITY),
277 +            () -> sr.nextDouble(Double.NaN),
278 +        };
279 +        assertThrows(IllegalArgumentException.class, throwingActions);
280 +    }
281 +
282 +    /**
283 +     * nextDouble(! (least < bound)) throws IllegalArgumentException
284 +     */
285 +    public void testNextDoubleBadBounds() {
286 +        SplittableRandom sr = new SplittableRandom();
287 +        Runnable[] throwingActions = {
288 +            () -> sr.nextDouble(17.0d, 2.0d),
289 +            () -> sr.nextDouble(-42.0d, -42.0d),
290 +            () -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
291 +            () -> sr.nextDouble(Double.NaN, 0.0d),
292 +            () -> sr.nextDouble(0.0d, Double.NaN),
293 +        };
294 +        assertThrows(IllegalArgumentException.class, throwingActions);
295 +    }
296 +
297 +    // TODO: Test infinite bounds!
298 +    //() -> sr.nextDouble(Double.NEGATIVE_INFINITY, 0.0d),
299 +    //() -> sr.nextDouble(0.0d, Double.POSITIVE_INFINITY),
300 +
301 +    /**
302       * nextDouble(least, bound) returns least <= value < bound;
303       * repeated calls produce at least two distinct results
304       */
# Line 284 | Line 326 | public class SplittableRandomTest extend
326       */
327      public void testBadStreamSize() {
328          SplittableRandom r = new SplittableRandom();
329 <        try {
330 <            java.util.stream.IntStream x = r.ints(-1L);
331 <            shouldThrow();
332 <        } catch (IllegalArgumentException success) {}
333 <        try {
334 <            java.util.stream.IntStream x = r.ints(-1L, 2, 3);
335 <            shouldThrow();
336 <        } catch (IllegalArgumentException success) {}
337 <        try {
296 <            java.util.stream.LongStream x = r.longs(-1L);
297 <            shouldThrow();
298 <        } catch (IllegalArgumentException success) {}
299 <        try {
300 <            java.util.stream.LongStream x = r.longs(-1L, -1L, 1L);
301 <            shouldThrow();
302 <        } catch (IllegalArgumentException success) {}
303 <        try {
304 <            java.util.stream.DoubleStream x = r.doubles(-1L);
305 <            shouldThrow();
306 <        } catch (IllegalArgumentException success) {}
307 <        try {
308 <            java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6);
309 <            shouldThrow();
310 <        } catch (IllegalArgumentException success) {}
329 >        Runnable[] throwingActions = {
330 >            () -> { java.util.stream.IntStream x = r.ints(-1L); },
331 >            () -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); },
332 >            () -> { java.util.stream.LongStream x = r.longs(-1L); },
333 >            () -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); },
334 >            () -> { java.util.stream.DoubleStream x = r.doubles(-1L); },
335 >            () -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); },
336 >        };
337 >        assertThrows(IllegalArgumentException.class, throwingActions);
338      }
339  
340      /**
# Line 316 | Line 343 | public class SplittableRandomTest extend
343       */
344      public void testBadStreamBounds() {
345          SplittableRandom r = new SplittableRandom();
346 <        try {
347 <            java.util.stream.IntStream x = r.ints(2, 1);
348 <            shouldThrow();
349 <        } catch (IllegalArgumentException success) {}
350 <        try {
351 <            java.util.stream.IntStream x = r.ints(10, 42, 42);
352 <            shouldThrow();
353 <        } catch (IllegalArgumentException success) {}
354 <        try {
328 <            java.util.stream.LongStream x = r.longs(-1L, -1L);
329 <            shouldThrow();
330 <        } catch (IllegalArgumentException success) {}
331 <        try {
332 <            java.util.stream.LongStream x = r.longs(10, 1L, -2L);
333 <            shouldThrow();
334 <        } catch (IllegalArgumentException success) {}
335 <        try {
336 <            java.util.stream.DoubleStream x = r.doubles(0.0, 0.0);
337 <            shouldThrow();
338 <        } catch (IllegalArgumentException success) {}
339 <        try {
340 <            java.util.stream.DoubleStream x = r.doubles(10, .5, .4);
341 <            shouldThrow();
342 <        } catch (IllegalArgumentException success) {}
346 >        Runnable[] throwingActions = {
347 >            () -> { java.util.stream.IntStream x = r.ints(2, 1); },
348 >            () -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
349 >            () -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
350 >            () -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
351 >            () -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
352 >            () -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
353 >        };
354 >        assertThrows(IllegalArgumentException.class, throwingActions);
355      }
356  
357      /**

Diff Legend

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