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.4 by jsr166, Sun Jul 14 16:55:01 2013 UTC vs.
Revision 1.8 by jsr166, Tue Sep 24 06:17:12 2013 UTC

#	Line 45 | Line 45 | public class SplittableRandomTest extend
45		static final long MAX_LONG_BOUND = (1L << 42);
46
47		// Number of replications for other checks
48	<	static final int REPS = 20;
48	>	static final int REPS =
49	>	Integer.getInteger("SplittableRandomTest.reps", 4);
50
51		/**
52		* Repeated calls to nextInt produce at least two distinct results
#	Line 283 | Line 284 | public class SplittableRandomTest extend
284		*/
285		public void testBadStreamSize() {
286		SplittableRandom r = new SplittableRandom();
287	<	try {
288	<	java.util.stream.IntStream x = r.ints(-1L);
289	<	shouldThrow();
290	<	} catch (IllegalArgumentException success) {}
291	<	try {
292	<	java.util.stream.LongStream x = r.longs(-1L);
293	<	shouldThrow();
294	<	} catch (IllegalArgumentException success) {}
295	<	try {
295	<	java.util.stream.DoubleStream x = r.doubles(-1L);
296	<	shouldThrow();
297	<	} catch (IllegalArgumentException success) {}
287	>	Runnable[] throwingActions = {
288	>	() -> { java.util.stream.IntStream x = r.ints(-1L); },
289	>	() -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); },
290	>	() -> { java.util.stream.LongStream x = r.longs(-1L); },
291	>	() -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); },
292	>	() -> { java.util.stream.DoubleStream x = r.doubles(-1L); },
293	>	() -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); },
294	>	};
295	>	assertThrows(IllegalArgumentException.class, throwingActions);
296		}
297
298		/**
#	Line 303 | Line 301 | public class SplittableRandomTest extend
301		*/
302		public void testBadStreamBounds() {
303		SplittableRandom r = new SplittableRandom();
304	<	try {
305	<	java.util.stream.IntStream x = r.ints(2, 1);
306	<	shouldThrow();
307	<	} catch (IllegalArgumentException success) {}
308	<	try {
309	<	java.util.stream.LongStream x = r.longs(1, -2);
310	<	shouldThrow();
311	<	} catch (IllegalArgumentException success) {}
312	<	try {
315	<	java.util.stream.DoubleStream x = r.doubles(0, 0);
316	<	shouldThrow();
317	<	} catch (IllegalArgumentException success) {}
304	>	Runnable[] throwingActions = {
305	>	() -> { java.util.stream.IntStream x = r.ints(2, 1); },
306	>	() -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
307	>	() -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
308	>	() -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
309	>	() -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
310	>	() -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
311	>	};
312	>	assertThrows(IllegalArgumentException.class, throwingActions);
313		}
314
315		/**
#	Line 326 | Line 321 | public class SplittableRandomTest extend
321		long size = 0;
322		for (int reps = 0; reps < REPS; ++reps) {
323		counter.reset();
324	<	r.ints(size).parallel().forEach(x -> {counter.increment();});
324	>	r.ints(size).parallel().forEach(x -> counter.increment());
325		assertEquals(size, counter.sum());
326		size += 524959;
327		}
#	Line 341 | Line 336 | public class SplittableRandomTest extend
336		long size = 0;
337		for (int reps = 0; reps < REPS; ++reps) {
338		counter.reset();
339	<	r.longs(size).parallel().forEach(x -> {counter.increment();});
339	>	r.longs(size).parallel().forEach(x -> counter.increment());
340		assertEquals(size, counter.sum());
341		size += 524959;
342		}
#	Line 356 | Line 351 | public class SplittableRandomTest extend
351		long size = 0;
352		for (int reps = 0; reps < REPS; ++reps) {
353		counter.reset();
354	<	r.doubles(size).parallel().forEach(x -> {counter.increment();});
354	>	r.doubles(size).parallel().forEach(x -> counter.increment());
355		assertEquals(size, counter.sum());
356		size += 524959;
357		}
#	Line 423 | Line 418 | public class SplittableRandomTest extend
418		LongAdder counter = new LongAdder();
419		SplittableRandom r = new SplittableRandom();
420		long size = 100;
421	<	r.ints().limit(size).parallel().forEach(x -> {counter.increment();});
421	>	r.ints().limit(size).parallel().forEach(x -> counter.increment());
422		assertEquals(size, counter.sum());
423		}
424
#	Line 434 | Line 429 | public class SplittableRandomTest extend
429		LongAdder counter = new LongAdder();
430		SplittableRandom r = new SplittableRandom();
431		long size = 100;
432	<	r.longs().limit(size).parallel().forEach(x -> {counter.increment();});
432	>	r.longs().limit(size).parallel().forEach(x -> counter.increment());
433		assertEquals(size, counter.sum());
434		}
435
#	Line 445 | Line 440 | public class SplittableRandomTest extend
440		LongAdder counter = new LongAdder();
441		SplittableRandom r = new SplittableRandom();
442		long size = 100;
443	<	r.doubles().limit(size).parallel().forEach(x -> {counter.increment();});
443	>	r.doubles().limit(size).parallel().forEach(x -> counter.increment());
444		assertEquals(size, counter.sum());
445		}
446
#	Line 456 | Line 451 | public class SplittableRandomTest extend
451		LongAdder counter = new LongAdder();
452		SplittableRandom r = new SplittableRandom();
453		long size = 100;
454	<	r.ints().limit(size).forEach(x -> {counter.increment();});
454	>	r.ints().limit(size).forEach(x -> counter.increment());
455		assertEquals(size, counter.sum());
456		}
457
#	Line 467 | Line 462 | public class SplittableRandomTest extend
462		LongAdder counter = new LongAdder();
463		SplittableRandom r = new SplittableRandom();
464		long size = 100;
465	<	r.longs().limit(size).forEach(x -> {counter.increment();});
465	>	r.longs().limit(size).forEach(x -> counter.increment());
466		assertEquals(size, counter.sum());
467		}
468
#	Line 478 | Line 473 | public class SplittableRandomTest extend
473		LongAdder counter = new LongAdder();
474		SplittableRandom r = new SplittableRandom();
475		long size = 100;
476	<	r.doubles().limit(size).forEach(x -> {counter.increment();});
476	>	r.doubles().limit(size).forEach(x -> counter.increment());
477		assertEquals(size, counter.sum());
478		}
479

Diff Legend

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