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.18 by jsr166, Sat Apr 25 04:55:31 2015 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6	<	import junit.framework.*;
7	<	import java.util.*;
6	>
7		import java.util.SplittableRandom;
8		import java.util.concurrent.atomic.AtomicInteger;
10	–	import java.util.concurrent.atomic.AtomicLong;
9		import java.util.concurrent.atomic.LongAdder;
10
11	+	import junit.framework.Test;
12	+	import junit.framework.TestSuite;
13	+
14		public class SplittableRandomTest extends JSR166TestCase {
15
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run(suite());
17	>	main(suite(), args);
18		}
19		public static Test suite() {
20		return new TestSuite(SplittableRandomTest.class);
#	Line 39 | Line 40 | public class SplittableRandomTest extend
40		static final int NCALLS = 10000;
41
42		// max sampled int bound
43	<	static final int MAX_INT_BOUND = (1 << 28);
43	>	static final int MAX_INT_BOUND = (1 << 26);
44
45		// max sampled long bound
46	<	static final long MAX_LONG_BOUND = (1L << 42);
46	>	static final long MAX_LONG_BOUND = (1L << 40);
47
48		// Number of replications for other checks
49	<	static final int REPS = 20;
49	>	static final int REPS =
50	>	Integer.getInteger("SplittableRandomTest.reps", 4);
51
52		/**
53		* Repeated calls to nextInt produce at least two distinct results
#	Line 88 | Line 90 | public class SplittableRandomTest extend
90		* same values for nextLong.
91		*/
92		public void testSeedConstructor() {
93	<	for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863)  {
93	>	for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863) {
94		SplittableRandom sr1 = new SplittableRandom(seed);
95		SplittableRandom sr2 = new SplittableRandom(seed);
96		for (int i = 0; i < REPS; ++i)
#	Line 127 | Line 129 | public class SplittableRandomTest extend
129		}
130
131		/**
132	<	* nextInt(negative) throws IllegalArgumentException
132	>	* nextInt(non-positive) throws IllegalArgumentException
133		*/
134	<	public void testNextIntBoundedNeg() {
134	>	public void testNextIntBoundNonPositive() {
135		SplittableRandom sr = new SplittableRandom();
136	<	try {
137	<	int f = sr.nextInt(-17);
138	<	shouldThrow();
139	<	} catch (IllegalArgumentException success) {}
136	>	Runnable[] throwingActions = {
137	>	() -> sr.nextInt(-17),
138	>	() -> sr.nextInt(0),
139	>	() -> sr.nextInt(Integer.MIN_VALUE),
140	>	};
141	>	assertThrows(IllegalArgumentException.class, throwingActions);
142		}
143
144		/**
#	Line 142 | Line 146 | public class SplittableRandomTest extend
146		*/
147		public void testNextIntBadBounds() {
148		SplittableRandom sr = new SplittableRandom();
149	<	try {
150	<	int f = sr.nextInt(17, 2);
151	<	shouldThrow();
152	<	} catch (IllegalArgumentException success) {}
149	>	Runnable[] throwingActions = {
150	>	() -> sr.nextInt(17, 2),
151	>	() -> sr.nextInt(-42, -42),
152	>	() -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE),
153	>	};
154	>	assertThrows(IllegalArgumentException.class, throwingActions);
155		}
156
157		/**
#	Line 192 | Line 198 | public class SplittableRandomTest extend
198		}
199
200		/**
201	<	* nextLong(negative) throws IllegalArgumentException
201	>	* nextLong(non-positive) throws IllegalArgumentException
202		*/
203	<	public void testNextLongBoundedNeg() {
203	>	public void testNextLongBoundNonPositive() {
204		SplittableRandom sr = new SplittableRandom();
205	<	try {
206	<	long f = sr.nextLong(-17);
207	<	shouldThrow();
208	<	} catch (IllegalArgumentException success) {}
205	>	Runnable[] throwingActions = {
206	>	() -> sr.nextLong(-17L),
207	>	() -> sr.nextLong(0L),
208	>	() -> sr.nextLong(Long.MIN_VALUE),
209	>	};
210	>	assertThrows(IllegalArgumentException.class, throwingActions);
211		}
212
213		/**
#	Line 207 | Line 215 | public class SplittableRandomTest extend
215		*/
216		public void testNextLongBadBounds() {
217		SplittableRandom sr = new SplittableRandom();
218	<	try {
219	<	long f = sr.nextLong(17, 2);
220	<	shouldThrow();
221	<	} catch (IllegalArgumentException success) {}
218	>	Runnable[] throwingActions = {
219	>	() -> sr.nextLong(17L, 2L),
220	>	() -> sr.nextLong(-42L, -42L),
221	>	() -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
222	>	};
223	>	assertThrows(IllegalArgumentException.class, throwingActions);
224		}
225
226		/**
#	Line 256 | Line 266 | public class SplittableRandomTest extend
266		}
267
268		/**
269	+	* nextDouble(non-positive) throws IllegalArgumentException
270	+	*/
271	+	public void testNextDoubleBoundNonPositive() {
272	+	SplittableRandom sr = new SplittableRandom();
273	+	Runnable[] throwingActions = {
274	+	() -> sr.nextDouble(-17.0d),
275	+	() -> sr.nextDouble(0.0d),
276	+	() -> sr.nextDouble(-Double.MIN_VALUE),
277	+	() -> sr.nextDouble(Double.NEGATIVE_INFINITY),
278	+	() -> sr.nextDouble(Double.NaN),
279	+	};
280	+	assertThrows(IllegalArgumentException.class, throwingActions);
281	+	}
282	+
283	+	/**
284	+	* nextDouble(! (least < bound)) throws IllegalArgumentException
285	+	*/
286	+	public void testNextDoubleBadBounds() {
287	+	SplittableRandom sr = new SplittableRandom();
288	+	Runnable[] throwingActions = {
289	+	() -> sr.nextDouble(17.0d, 2.0d),
290	+	() -> sr.nextDouble(-42.0d, -42.0d),
291	+	() -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
292	+	() -> sr.nextDouble(Double.NaN, 0.0d),
293	+	() -> sr.nextDouble(0.0d, Double.NaN),
294	+	};
295	+	assertThrows(IllegalArgumentException.class, throwingActions);
296	+	}
297	+
298	+	// TODO: Test infinite bounds!
299	+	//() -> sr.nextDouble(Double.NEGATIVE_INFINITY, 0.0d),
300	+	//() -> sr.nextDouble(0.0d, Double.POSITIVE_INFINITY),
301	+
302	+	/**
303		* nextDouble(least, bound) returns least <= value < bound;
304		* repeated calls produce at least two distinct results
305		*/
#	Line 283 | Line 327 | public class SplittableRandomTest extend
327		*/
328		public void testBadStreamSize() {
329		SplittableRandom r = new SplittableRandom();
330	<	try {
331	<	java.util.stream.IntStream x = r.ints(-1L);
332	<	shouldThrow();
333	<	} catch (IllegalArgumentException success) {}
334	<	try {
335	<	java.util.stream.LongStream x = r.longs(-1L);
336	<	shouldThrow();
337	<	} catch (IllegalArgumentException success) {}
338	<	try {
295	<	java.util.stream.DoubleStream x = r.doubles(-1L);
296	<	shouldThrow();
297	<	} catch (IllegalArgumentException success) {}
330	>	Runnable[] throwingActions = {
331	>	() -> { java.util.stream.IntStream x = r.ints(-1L); },
332	>	() -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); },
333	>	() -> { java.util.stream.LongStream x = r.longs(-1L); },
334	>	() -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); },
335	>	() -> { java.util.stream.DoubleStream x = r.doubles(-1L); },
336	>	() -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); },
337	>	};
338	>	assertThrows(IllegalArgumentException.class, throwingActions);
339		}
340
341		/**
#	Line 303 | Line 344 | public class SplittableRandomTest extend
344		*/
345		public void testBadStreamBounds() {
346		SplittableRandom r = new SplittableRandom();
347	<	try {
348	<	java.util.stream.IntStream x = r.ints(2, 1);
349	<	shouldThrow();
350	<	} catch (IllegalArgumentException success) {}
351	<	try {
352	<	java.util.stream.LongStream x = r.longs(1, -2);
353	<	shouldThrow();
354	<	} catch (IllegalArgumentException success) {}
355	<	try {
315	<	java.util.stream.DoubleStream x = r.doubles(0, 0);
316	<	shouldThrow();
317	<	} catch (IllegalArgumentException success) {}
347	>	Runnable[] throwingActions = {
348	>	() -> { java.util.stream.IntStream x = r.ints(2, 1); },
349	>	() -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
350	>	() -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
351	>	() -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
352	>	() -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
353	>	() -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
354	>	};
355	>	assertThrows(IllegalArgumentException.class, throwingActions);
356		}
357
358		/**
#	Line 326 | Line 364 | public class SplittableRandomTest extend
364		long size = 0;
365		for (int reps = 0; reps < REPS; ++reps) {
366		counter.reset();
367	<	r.ints(size).parallel().forEach(x -> {counter.increment();});
367	>	r.ints(size).parallel().forEach(x -> counter.increment());
368		assertEquals(size, counter.sum());
369		size += 524959;
370		}
#	Line 341 | Line 379 | public class SplittableRandomTest extend
379		long size = 0;
380		for (int reps = 0; reps < REPS; ++reps) {
381		counter.reset();
382	<	r.longs(size).parallel().forEach(x -> {counter.increment();});
382	>	r.longs(size).parallel().forEach(x -> counter.increment());
383		assertEquals(size, counter.sum());
384		size += 524959;
385		}
#	Line 356 | Line 394 | public class SplittableRandomTest extend
394		long size = 0;
395		for (int reps = 0; reps < REPS; ++reps) {
396		counter.reset();
397	<	r.doubles(size).parallel().forEach(x -> {counter.increment();});
397	>	r.doubles(size).parallel().forEach(x -> counter.increment());
398		assertEquals(size, counter.sum());
399		size += 524959;
400		}
#	Line 372 | Line 410 | public class SplittableRandomTest extend
410		for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) {
411		for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) {
412		final int lo = least, hi = bound;
413	<	r.ints(size, lo, hi).parallel().
414	<	forEach(x -> {if (x < lo || x >= hi)
415	<	fails.getAndIncrement(); });
413	>	r.ints(size, lo, hi).parallel().forEach(
414	>	x -> {
415	>	if (x < lo || x >= hi)
416	>	fails.getAndIncrement(); });
417		}
418		}
419		assertEquals(0, fails.get());
#	Line 390 | Line 429 | public class SplittableRandomTest extend
429		for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) {
430		for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) {
431		final long lo = least, hi = bound;
432	<	r.longs(size, lo, hi).parallel().
433	<	forEach(x -> {if (x < lo || x >= hi)
434	<	fails.getAndIncrement(); });
432	>	r.longs(size, lo, hi).parallel().forEach(
433	>	x -> {
434	>	if (x < lo || x >= hi)
435	>	fails.getAndIncrement(); });
436		}
437		}
438		assertEquals(0, fails.get());
#	Line 408 | Line 448 | public class SplittableRandomTest extend
448		for (double least = 0.00011; least < 1.0e20; least *= 9) {
449		for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) {
450		final double lo = least, hi = bound;
451	<	r.doubles(size, lo, hi).parallel().
452	<	forEach(x -> {if (x < lo || x >= hi)
453	<	fails.getAndIncrement(); });
451	>	r.doubles(size, lo, hi).parallel().forEach(
452	>	x -> {
453	>	if (x < lo || x >= hi)
454	>	fails.getAndIncrement(); });
455		}
456		}
457		assertEquals(0, fails.get());
#	Line 423 | Line 464 | public class SplittableRandomTest extend
464		LongAdder counter = new LongAdder();
465		SplittableRandom r = new SplittableRandom();
466		long size = 100;
467	<	r.ints().limit(size).parallel().forEach(x -> {counter.increment();});
467	>	r.ints().limit(size).parallel().forEach(x -> counter.increment());
468		assertEquals(size, counter.sum());
469		}
470
#	Line 434 | Line 475 | public class SplittableRandomTest extend
475		LongAdder counter = new LongAdder();
476		SplittableRandom r = new SplittableRandom();
477		long size = 100;
478	<	r.longs().limit(size).parallel().forEach(x -> {counter.increment();});
478	>	r.longs().limit(size).parallel().forEach(x -> counter.increment());
479		assertEquals(size, counter.sum());
480		}
481
#	Line 445 | Line 486 | public class SplittableRandomTest extend
486		LongAdder counter = new LongAdder();
487		SplittableRandom r = new SplittableRandom();
488		long size = 100;
489	<	r.doubles().limit(size).parallel().forEach(x -> {counter.increment();});
489	>	r.doubles().limit(size).parallel().forEach(x -> counter.increment());
490		assertEquals(size, counter.sum());
491		}
492
#	Line 456 | Line 497 | public class SplittableRandomTest extend
497		LongAdder counter = new LongAdder();
498		SplittableRandom r = new SplittableRandom();
499		long size = 100;
500	<	r.ints().limit(size).forEach(x -> {counter.increment();});
500	>	r.ints().limit(size).forEach(x -> counter.increment());
501		assertEquals(size, counter.sum());
502		}
503
#	Line 467 | Line 508 | public class SplittableRandomTest extend
508		LongAdder counter = new LongAdder();
509		SplittableRandom r = new SplittableRandom();
510		long size = 100;
511	<	r.longs().limit(size).forEach(x -> {counter.increment();});
511	>	r.longs().limit(size).forEach(x -> counter.increment());
512		assertEquals(size, counter.sum());
513		}
514
#	Line 478 | Line 519 | public class SplittableRandomTest extend
519		LongAdder counter = new LongAdder();
520		SplittableRandom r = new SplittableRandom();
521		long size = 100;
522	<	r.doubles().limit(size).forEach(x -> {counter.increment();});
522	>	r.doubles().limit(size).forEach(x -> counter.increment());
523		assertEquals(size, counter.sum());
524		}
525

Diff Legend

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