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.7 by jsr166, Mon Sep 23 17:23:50 2013 UTC vs.
Revision 1.19 by jsr166, Sun Sep 20 21:16:08 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 =
#	Line 89 | 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 128 | 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 143 | 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 155 | Line 160 | public class SplittableRandomTest extend
160		*/
161		public void testNextIntBounded() {
162		SplittableRandom sr = new SplittableRandom();
163	+	for (int i = 0; i < 2; i++) assertEquals(0, sr.nextInt(1));
164		// sample bound space across prime number increments
165		for (int bound = 2; bound < MAX_INT_BOUND; bound += 524959) {
166		int f = sr.nextInt(bound);
#	Line 193 | Line 199 | public class SplittableRandomTest extend
199		}
200
201		/**
202	<	* nextLong(negative) throws IllegalArgumentException
202	>	* nextLong(non-positive) throws IllegalArgumentException
203		*/
204	<	public void testNextLongBoundedNeg() {
204	>	public void testNextLongBoundNonPositive() {
205		SplittableRandom sr = new SplittableRandom();
206	<	try {
207	<	long f = sr.nextLong(-17);
208	<	shouldThrow();
209	<	} catch (IllegalArgumentException success) {}
206	>	Runnable[] throwingActions = {
207	>	() -> sr.nextLong(-17L),
208	>	() -> sr.nextLong(0L),
209	>	() -> sr.nextLong(Long.MIN_VALUE),
210	>	};
211	>	assertThrows(IllegalArgumentException.class, throwingActions);
212		}
213
214		/**
#	Line 208 | Line 216 | public class SplittableRandomTest extend
216		*/
217		public void testNextLongBadBounds() {
218		SplittableRandom sr = new SplittableRandom();
219	<	try {
220	<	long f = sr.nextLong(17, 2);
221	<	shouldThrow();
222	<	} catch (IllegalArgumentException success) {}
219	>	Runnable[] throwingActions = {
220	>	() -> sr.nextLong(17L, 2L),
221	>	() -> sr.nextLong(-42L, -42L),
222	>	() -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE),
223	>	};
224	>	assertThrows(IllegalArgumentException.class, throwingActions);
225		}
226
227		/**
#	Line 220 | Line 230 | public class SplittableRandomTest extend
230		*/
231		public void testNextLongBounded() {
232		SplittableRandom sr = new SplittableRandom();
233	+	for (int i = 0; i < 2; i++) assertEquals(0L, sr.nextLong(1L));
234		for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) {
235		long f = sr.nextLong(bound);
236		assertTrue(0 <= f && f < bound);
#	Line 257 | Line 268 | public class SplittableRandomTest extend
268		}
269
270		/**
271	+	* nextDouble(non-positive) throws IllegalArgumentException
272	+	*/
273	+	public void testNextDoubleBoundNonPositive() {
274	+	SplittableRandom sr = new SplittableRandom();
275	+	Runnable[] throwingActions = {
276	+	() -> sr.nextDouble(-17.0d),
277	+	() -> sr.nextDouble(0.0d),
278	+	() -> sr.nextDouble(-Double.MIN_VALUE),
279	+	() -> sr.nextDouble(Double.NEGATIVE_INFINITY),
280	+	() -> sr.nextDouble(Double.NaN),
281	+	};
282	+	assertThrows(IllegalArgumentException.class, throwingActions);
283	+	}
284	+
285	+	/**
286	+	* nextDouble(! (least < bound)) throws IllegalArgumentException
287	+	*/
288	+	public void testNextDoubleBadBounds() {
289	+	SplittableRandom sr = new SplittableRandom();
290	+	Runnable[] throwingActions = {
291	+	() -> sr.nextDouble(17.0d, 2.0d),
292	+	() -> sr.nextDouble(-42.0d, -42.0d),
293	+	() -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE),
294	+	() -> sr.nextDouble(Double.NaN, 0.0d),
295	+	() -> sr.nextDouble(0.0d, Double.NaN),
296	+	};
297	+	assertThrows(IllegalArgumentException.class, throwingActions);
298	+	}
299	+
300	+	// TODO: Test infinite bounds!
301	+	//() -> sr.nextDouble(Double.NEGATIVE_INFINITY, 0.0d),
302	+	//() -> sr.nextDouble(0.0d, Double.POSITIVE_INFINITY),
303	+
304	+	/**
305		* nextDouble(least, bound) returns least <= value < bound;
306		* repeated calls produce at least two distinct results
307		*/
#	Line 284 | Line 329 | public class SplittableRandomTest extend
329		*/
330		public void testBadStreamSize() {
331		SplittableRandom r = new SplittableRandom();
332	<	try {
333	<	java.util.stream.IntStream x = r.ints(-1L);
334	<	shouldThrow();
335	<	} catch (IllegalArgumentException success) {}
336	<	try {
337	<	java.util.stream.IntStream x = r.ints(-1L, 2, 3);
338	<	shouldThrow();
339	<	} catch (IllegalArgumentException success) {}
340	<	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) {}
332	>	Runnable[] throwingActions = {
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); },
339	>	};
340	>	assertThrows(IllegalArgumentException.class, throwingActions);
341		}
342
343		/**
#	Line 316 | Line 346 | public class SplittableRandomTest extend
346		*/
347		public void testBadStreamBounds() {
348		SplittableRandom r = new SplittableRandom();
349	<	try {
350	<	java.util.stream.IntStream x = r.ints(2, 1);
351	<	shouldThrow();
352	<	} catch (IllegalArgumentException success) {}
353	<	try {
354	<	java.util.stream.IntStream x = r.ints(10, 42, 42);
355	<	shouldThrow();
356	<	} catch (IllegalArgumentException success) {}
357	<	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(10, .5, .4);
341	<	shouldThrow();
342	<	} catch (IllegalArgumentException success) {}
349	>	Runnable[] throwingActions = {
350	>	() -> { java.util.stream.IntStream x = r.ints(2, 1); },
351	>	() -> { java.util.stream.IntStream x = r.ints(10, 42, 42); },
352	>	() -> { java.util.stream.LongStream x = r.longs(-1L, -1L); },
353	>	() -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); },
354	>	() -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); },
355	>	() -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); },
356	>	};
357	>	assertThrows(IllegalArgumentException.class, throwingActions);
358		}
359
360		/**
#	Line 397 | Line 412 | public class SplittableRandomTest extend
412		for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) {
413		for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) {
414		final int lo = least, hi = bound;
415	<	r.ints(size, lo, hi).parallel().
416	<	forEach(x -> {if (x < lo || x >= hi)
417	<	fails.getAndIncrement(); });
415	>	r.ints(size, lo, hi).parallel().forEach(
416	>	x -> {
417	>	if (x < lo || x >= hi)
418	>	fails.getAndIncrement(); });
419		}
420		}
421		assertEquals(0, fails.get());
#	Line 415 | Line 431 | public class SplittableRandomTest extend
431		for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) {
432		for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) {
433		final long lo = least, hi = bound;
434	<	r.longs(size, lo, hi).parallel().
435	<	forEach(x -> {if (x < lo || x >= hi)
436	<	fails.getAndIncrement(); });
434	>	r.longs(size, lo, hi).parallel().forEach(
435	>	x -> {
436	>	if (x < lo || x >= hi)
437	>	fails.getAndIncrement(); });
438		}
439		}
440		assertEquals(0, fails.get());
#	Line 433 | Line 450 | public class SplittableRandomTest extend
450		for (double least = 0.00011; least < 1.0e20; least *= 9) {
451		for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) {
452		final double lo = least, hi = bound;
453	<	r.doubles(size, lo, hi).parallel().
454	<	forEach(x -> {if (x < lo || x >= hi)
455	<	fails.getAndIncrement(); });
453	>	r.doubles(size, lo, hi).parallel().forEach(
454	>	x -> {
455	>	if (x < lo || x >= hi)
456	>	fails.getAndIncrement(); });
457		}
458		}
459		assertEquals(0, fails.get());

Diff Legend

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