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.24 by jsr166, Fri Oct 13 16:14:40 2017 UTC vs.
Revision 1.26 by jsr166, Mon Dec 16 22:55:54 2019 UTC

# Line 12 | Line 12 | import java.util.concurrent.atomic.LongA
12   import java.lang.reflect.Method;
13   import java.util.function.Predicate;
14   import java.util.stream.Collectors;
15 + import java.util.stream.DoubleStream;
16 + import java.util.stream.IntStream;
17 + import java.util.stream.LongStream;
18  
19   import junit.framework.Test;
20   import junit.framework.TestSuite;
# Line 138 | Line 141 | public class SplittableRandomTest extend
141       */
142      public void testNextIntBoundNonPositive() {
143          SplittableRandom sr = new SplittableRandom();
144 <        Runnable[] throwingActions = {
144 >        assertThrows(
145 >            IllegalArgumentException.class,
146              () -> sr.nextInt(-17),
147              () -> sr.nextInt(0),
148 <            () -> sr.nextInt(Integer.MIN_VALUE),
145 <        };
146 <        assertThrows(IllegalArgumentException.class, throwingActions);
148 >            () -> sr.nextInt(Integer.MIN_VALUE));
149      }
150  
151      /**
# Line 151 | Line 153 | public class SplittableRandomTest extend
153       */
154      public void testNextIntBadBounds() {
155          SplittableRandom sr = new SplittableRandom();
156 <        Runnable[] throwingActions = {
156 >        assertThrows(
157 >            IllegalArgumentException.class,
158              () -> sr.nextInt(17, 2),
159              () -> sr.nextInt(-42, -42),
160 <            () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
158 <        };
159 <        assertThrows(IllegalArgumentException.class, throwingActions);
160 >            () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE));
161      }
162  
163      /**
# Line 208 | Line 209 | public class SplittableRandomTest extend
209       */
210      public void testNextLongBoundNonPositive() {
211          SplittableRandom sr = new SplittableRandom();
212 <        Runnable[] throwingActions = {
212 >        assertThrows(
213 >            IllegalArgumentException.class,
214              () -> sr.nextLong(-17L),
215              () -> sr.nextLong(0L),
216 <            () -> sr.nextLong(Long.MIN_VALUE),
215 <        };
216 <        assertThrows(IllegalArgumentException.class, throwingActions);
216 >            () -> sr.nextLong(Long.MIN_VALUE));
217      }
218  
219      /**
# Line 221 | Line 221 | public class SplittableRandomTest extend
221       */
222      public void testNextLongBadBounds() {
223          SplittableRandom sr = new SplittableRandom();
224 <        Runnable[] throwingActions = {
224 >        assertThrows(
225 >            IllegalArgumentException.class,
226              () -> sr.nextLong(17L, 2L),
227              () -> sr.nextLong(-42L, -42L),
228 <            () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
228 <        };
229 <        assertThrows(IllegalArgumentException.class, throwingActions);
228 >            () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE));
229      }
230  
231      /**
# Line 277 | Line 276 | public class SplittableRandomTest extend
276       */
277      public void testNextDoubleBoundNonPositive() {
278          SplittableRandom sr = new SplittableRandom();
279 <        Runnable[] throwingActions = {
279 >        assertThrows(
280 >            IllegalArgumentException.class,
281              () -> sr.nextDouble(-17.0d),
282              () -> sr.nextDouble(0.0d),
283              () -> sr.nextDouble(-Double.MIN_VALUE),
284              () -> sr.nextDouble(Double.NEGATIVE_INFINITY),
285 <            () -> sr.nextDouble(Double.NaN),
286 <        };
287 <        assertThrows(IllegalArgumentException.class, throwingActions);
285 >            () -> sr.nextDouble(Double.NaN));
286      }
287  
288      /**
# Line 292 | Line 290 | public class SplittableRandomTest extend
290       */
291      public void testNextDoubleBadBounds() {
292          SplittableRandom sr = new SplittableRandom();
293 <        Runnable[] throwingActions = {
293 >        assertThrows(
294 >            IllegalArgumentException.class,
295              () -> sr.nextDouble(17.0d, 2.0d),
296              () -> sr.nextDouble(-42.0d, -42.0d),
297              () -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
298              () -> sr.nextDouble(Double.NaN, 0.0d),
299 <            () -> sr.nextDouble(0.0d, Double.NaN),
301 <        };
302 <        assertThrows(IllegalArgumentException.class, throwingActions);
299 >            () -> sr.nextDouble(0.0d, Double.NaN));
300      }
301  
302      // TODO: Test infinite bounds!
# Line 334 | Line 331 | public class SplittableRandomTest extend
331       */
332      public void testBadStreamSize() {
333          SplittableRandom r = new SplittableRandom();
334 <        Runnable[] throwingActions = {
335 <            () -> { java.util.stream.IntStream x = r.ints(-1L); },
336 <            () -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); },
337 <            () -> { java.util.stream.LongStream x = r.longs(-1L); },
338 <            () -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); },
339 <            () -> { java.util.stream.DoubleStream x = r.doubles(-1L); },
340 <            () -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); },
341 <        };
345 <        assertThrows(IllegalArgumentException.class, throwingActions);
334 >        assertThrows(
335 >            IllegalArgumentException.class,
336 >            () -> { IntStream unused = r.ints(-1L); },
337 >            () -> { IntStream unused = r.ints(-1L, 2, 3); },
338 >            () -> { LongStream unused = r.longs(-1L); },
339 >            () -> { LongStream unused = r.longs(-1L, -1L, 1L); },
340 >            () -> { DoubleStream unused = r.doubles(-1L); },
341 >            () -> { DoubleStream unused = r.doubles(-1L, .5, .6); });
342      }
343  
344      /**
# Line 351 | Line 347 | public class SplittableRandomTest extend
347       */
348      public void testBadStreamBounds() {
349          SplittableRandom r = new SplittableRandom();
350 <        Runnable[] throwingActions = {
351 <            () -> { java.util.stream.IntStream x = r.ints(2, 1); },
352 <            () -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
353 <            () -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
354 <            () -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
355 <            () -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
356 <            () -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
357 <        };
362 <        assertThrows(IllegalArgumentException.class, throwingActions);
350 >        assertThrows(
351 >            IllegalArgumentException.class,
352 >            () -> { IntStream unused = r.ints(2, 1); },
353 >            () -> { IntStream unused = r.ints(10, 42, 42); },
354 >            () -> { LongStream unused = r.longs(-1L, -1L); },
355 >            () -> { LongStream unused = r.longs(10, 1L, -2L); },
356 >            () -> { DoubleStream unused = r.doubles(0.0, 0.0); },
357 >            () -> { DoubleStream unused = r.doubles(10, .5, .4); });
358      }
359  
360      /**

Diff Legend

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