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.7 by jsr166, Mon Sep 23 17:23:50 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 288 | Line 289 | public class SplittableRandomTest extend
289		shouldThrow();
290		} catch (IllegalArgumentException success) {}
291		try {
292	+	java.util.stream.IntStream x = r.ints(-1L, 2, 3);
293	+	shouldThrow();
294	+	} catch (IllegalArgumentException success) {}
295	+	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) {}
311		}
312
313		/**
#	Line 308 | Line 321 | public class SplittableRandomTest extend
321		shouldThrow();
322		} catch (IllegalArgumentException success) {}
323		try {
324	<	java.util.stream.LongStream x = r.longs(1, -2);
324	>	java.util.stream.IntStream x = r.ints(10, 42, 42);
325	>	shouldThrow();
326	>	} catch (IllegalArgumentException success) {}
327	>	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(0, 0);
340	>	java.util.stream.DoubleStream x = r.doubles(10, .5, .4);
341		shouldThrow();
342		} catch (IllegalArgumentException success) {}
343		}
#	Line 326 | Line 351 | public class SplittableRandomTest extend
351		long size = 0;
352		for (int reps = 0; reps < REPS; ++reps) {
353		counter.reset();
354	<	r.ints(size).parallel().forEach(x -> {counter.increment();});
354	>	r.ints(size).parallel().forEach(x -> counter.increment());
355		assertEquals(size, counter.sum());
356		size += 524959;
357		}
#	Line 341 | Line 366 | public class SplittableRandomTest extend
366		long size = 0;
367		for (int reps = 0; reps < REPS; ++reps) {
368		counter.reset();
369	<	r.longs(size).parallel().forEach(x -> {counter.increment();});
369	>	r.longs(size).parallel().forEach(x -> counter.increment());
370		assertEquals(size, counter.sum());
371		size += 524959;
372		}
#	Line 356 | Line 381 | public class SplittableRandomTest extend
381		long size = 0;
382		for (int reps = 0; reps < REPS; ++reps) {
383		counter.reset();
384	<	r.doubles(size).parallel().forEach(x -> {counter.increment();});
384	>	r.doubles(size).parallel().forEach(x -> counter.increment());
385		assertEquals(size, counter.sum());
386		size += 524959;
387		}
#	Line 423 | Line 448 | public class SplittableRandomTest extend
448		LongAdder counter = new LongAdder();
449		SplittableRandom r = new SplittableRandom();
450		long size = 100;
451	<	r.ints().limit(size).parallel().forEach(x -> {counter.increment();});
451	>	r.ints().limit(size).parallel().forEach(x -> counter.increment());
452		assertEquals(size, counter.sum());
453		}
454
#	Line 434 | Line 459 | public class SplittableRandomTest extend
459		LongAdder counter = new LongAdder();
460		SplittableRandom r = new SplittableRandom();
461		long size = 100;
462	<	r.longs().limit(size).parallel().forEach(x -> {counter.increment();});
462	>	r.longs().limit(size).parallel().forEach(x -> counter.increment());
463		assertEquals(size, counter.sum());
464		}
465
#	Line 445 | Line 470 | public class SplittableRandomTest extend
470		LongAdder counter = new LongAdder();
471		SplittableRandom r = new SplittableRandom();
472		long size = 100;
473	<	r.doubles().limit(size).parallel().forEach(x -> {counter.increment();});
473	>	r.doubles().limit(size).parallel().forEach(x -> counter.increment());
474		assertEquals(size, counter.sum());
475		}
476
#	Line 456 | Line 481 | public class SplittableRandomTest extend
481		LongAdder counter = new LongAdder();
482		SplittableRandom r = new SplittableRandom();
483		long size = 100;
484	<	r.ints().limit(size).forEach(x -> {counter.increment();});
484	>	r.ints().limit(size).forEach(x -> counter.increment());
485		assertEquals(size, counter.sum());
486		}
487
#	Line 467 | Line 492 | public class SplittableRandomTest extend
492		LongAdder counter = new LongAdder();
493		SplittableRandom r = new SplittableRandom();
494		long size = 100;
495	<	r.longs().limit(size).forEach(x -> {counter.increment();});
495	>	r.longs().limit(size).forEach(x -> counter.increment());
496		assertEquals(size, counter.sum());
497		}
498
#	Line 478 | Line 503 | public class SplittableRandomTest extend
503		LongAdder counter = new LongAdder();
504		SplittableRandom r = new SplittableRandom();
505		long size = 100;
506	<	r.doubles().limit(size).forEach(x -> {counter.increment();});
506	>	r.doubles().limit(size).forEach(x -> counter.increment());
507		assertEquals(size, counter.sum());
508		}
509

Diff Legend

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