ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/SplittableRandomTest.java

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.25 by jsr166, Fri Feb 22 19:27:47 2019 UTC

#	Line 138 | Line 138 | public class SplittableRandomTest extend
138		*/
139		public void testNextIntBoundNonPositive() {
140		SplittableRandom sr = new SplittableRandom();
141	<	Runnable[] throwingActions = {
141	>	assertThrows(
142	>	IllegalArgumentException.class,
143		() -> sr.nextInt(-17),
144		() -> sr.nextInt(0),
145	<	() -> sr.nextInt(Integer.MIN_VALUE),
145	<	};
146	<	assertThrows(IllegalArgumentException.class, throwingActions);
145	>	() -> sr.nextInt(Integer.MIN_VALUE));
146		}
147
148		/**
#	Line 151 | Line 150 | public class SplittableRandomTest extend
150		*/
151		public void testNextIntBadBounds() {
152		SplittableRandom sr = new SplittableRandom();
153	<	Runnable[] throwingActions = {
153	>	assertThrows(
154	>	IllegalArgumentException.class,
155		() -> sr.nextInt(17, 2),
156		() -> sr.nextInt(-42, -42),
157	<	() -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
158	<	};
159	<	assertThrows(IllegalArgumentException.class, throwingActions);
157	>	() -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE));
158		}
159
160		/**
#	Line 208 | Line 206 | public class SplittableRandomTest extend
206		*/
207		public void testNextLongBoundNonPositive() {
208		SplittableRandom sr = new SplittableRandom();
209	<	Runnable[] throwingActions = {
209	>	assertThrows(
210	>	IllegalArgumentException.class,
211		() -> sr.nextLong(-17L),
212		() -> sr.nextLong(0L),
213	<	() -> sr.nextLong(Long.MIN_VALUE),
215	<	};
216	<	assertThrows(IllegalArgumentException.class, throwingActions);
213	>	() -> sr.nextLong(Long.MIN_VALUE));
214		}
215
216		/**
#	Line 221 | Line 218 | public class SplittableRandomTest extend
218		*/
219		public void testNextLongBadBounds() {
220		SplittableRandom sr = new SplittableRandom();
221	<	Runnable[] throwingActions = {
221	>	assertThrows(
222	>	IllegalArgumentException.class,
223		() -> sr.nextLong(17L, 2L),
224		() -> sr.nextLong(-42L, -42L),
225	<	() -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
228	<	};
229	<	assertThrows(IllegalArgumentException.class, throwingActions);
225	>	() -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE));
226		}
227
228		/**
#	Line 277 | Line 273 | public class SplittableRandomTest extend
273		*/
274		public void testNextDoubleBoundNonPositive() {
275		SplittableRandom sr = new SplittableRandom();
276	<	Runnable[] throwingActions = {
276	>	assertThrows(
277	>	IllegalArgumentException.class,
278		() -> sr.nextDouble(-17.0d),
279		() -> sr.nextDouble(0.0d),
280		() -> sr.nextDouble(-Double.MIN_VALUE),
281		() -> sr.nextDouble(Double.NEGATIVE_INFINITY),
282	<	() -> sr.nextDouble(Double.NaN),
286	<	};
287	<	assertThrows(IllegalArgumentException.class, throwingActions);
282	>	() -> sr.nextDouble(Double.NaN));
283		}
284
285		/**
#	Line 292 | Line 287 | public class SplittableRandomTest extend
287		*/
288		public void testNextDoubleBadBounds() {
289		SplittableRandom sr = new SplittableRandom();
290	<	Runnable[] throwingActions = {
290	>	assertThrows(
291	>	IllegalArgumentException.class,
292		() -> sr.nextDouble(17.0d, 2.0d),
293		() -> sr.nextDouble(-42.0d, -42.0d),
294		() -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
295		() -> sr.nextDouble(Double.NaN, 0.0d),
296	<	() -> sr.nextDouble(0.0d, Double.NaN),
301	<	};
302	<	assertThrows(IllegalArgumentException.class, throwingActions);
296	>	() -> sr.nextDouble(0.0d, Double.NaN));
297		}
298
299		// TODO: Test infinite bounds!
#	Line 334 | Line 328 | public class SplittableRandomTest extend
328		*/
329		public void testBadStreamSize() {
330		SplittableRandom r = new SplittableRandom();
331	<	Runnable[] throwingActions = {
331	>	assertThrows(
332	>	IllegalArgumentException.class,
333		() -> { java.util.stream.IntStream x = r.ints(-1L); },
334		() -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); },
335		() -> { java.util.stream.LongStream x = r.longs(-1L); },
336		() -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); },
337		() -> { java.util.stream.DoubleStream x = r.doubles(-1L); },
338	<	() -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); },
344	<	};
345	<	assertThrows(IllegalArgumentException.class, throwingActions);
338	>	() -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); });
339		}
340
341		/**
#	Line 351 | Line 344 | public class SplittableRandomTest extend
344		*/
345		public void testBadStreamBounds() {
346		SplittableRandom r = new SplittableRandom();
347	<	Runnable[] throwingActions = {
347	>	assertThrows(
348	>	IllegalArgumentException.class,
349		() -> { java.util.stream.IntStream x = r.ints(2, 1); },
350		() -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
351		() -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
352		() -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
353		() -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
354	<	() -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
361	<	};
362	<	assertThrows(IllegalArgumentException.class, throwingActions);
354	>	() -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); });
355		}
356
357		/**

Diff Legend

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