ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadLocalRandomTest.java (file contents):
Revision 1.15 by dl, Wed Aug 14 12:41:18 2013 UTC vs.
Revision 1.25 by jsr166, Tue Sep 19 20:10:49 2017 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.concurrent.ThreadLocalRandom;
8		import java.util.concurrent.atomic.AtomicLong;
10	–	import java.util.concurrent.atomic.AtomicInteger;
9		import java.util.concurrent.atomic.AtomicReference;
10	<	import java.util.concurrent.atomic.LongAdder;
10	>
11	>	import junit.framework.Test;
12	>	import junit.framework.TestSuite;
13
14		public class ThreadLocalRandomTest 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(ThreadLocalRandomTest.class);
#	Line 52 | Line 52 | public class ThreadLocalRandomTest exten
52		}
53
54		/**
55	+	* Repeated calls to next (only accessible via reflection) produce
56	+	* at least two distinct results, and repeated calls produce all
57	+	* possible values.
58	+	*/
59	+	public void testNext() throws ReflectiveOperationException {
60	+	// Inhibit "An illegal reflective access operation has occurred"
61	+	if (!testImplementationDetails) return;
62	+
63	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
64	+	final java.lang.reflect.Method m;
65	+	try {
66	+	m = ThreadLocalRandom.class.getDeclaredMethod(
67	+	"next", new Class[] { int.class });
68	+	m.setAccessible(true);
69	+	} catch (SecurityException acceptable) {
70	+	// Security manager may deny access
71	+	return;
72	+	} catch (Exception ex) {
73	+	// jdk9 module system may deny access
74	+	if (ex.getClass().getSimpleName()
75	+	.equals("InaccessibleObjectException"))
76	+	return;
77	+	throw ex;
78	+	}
79	+
80	+	int i;
81	+	{
82	+	int val = new java.util.Random().nextInt(4);
83	+	for (i = 0; i < NCALLS; i++) {
84	+	int q = (int) m.invoke(rnd, new Object[] { 2 });
85	+	if (val == q) break;
86	+	}
87	+	assertTrue(i < NCALLS);
88	+	}
89	+
90	+	{
91	+	int r = (int) m.invoke(rnd, new Object[] { 3 });
92	+	for (i = 0; i < NCALLS; i++) {
93	+	int q = (int) m.invoke(rnd, new Object[] { 3 });
94	+	assertTrue(q < (1<<3));
95	+	if (r != q) break;
96	+	}
97	+	assertTrue(i < NCALLS);
98	+	}
99	+	}
100	+
101	+	/**
102		* Repeated calls to nextInt produce at least two distinct results
103		*/
104		public void testNextInt() {
#	Line 118 | Line 165 | public class ThreadLocalRandomTest exten
165		}
166
167		/**
168	<	* nextInt(negative) throws IllegalArgumentException
168	>	* nextInt(non-positive) throws IllegalArgumentException
169		*/
170	<	public void testNextIntBoundedNeg() {
171	<	try {
172	<	int f = ThreadLocalRandom.current().nextInt(-17);
173	<	shouldThrow();
174	<	} catch (IllegalArgumentException success) {}
170	>	public void testNextIntBoundNonPositive() {
171	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
172	>	for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
173	>	try {
174	>	rnd.nextInt(bound);
175	>	shouldThrow();
176	>	} catch (IllegalArgumentException success) {}
177	>	}
178		}
179
180		/**
181		* nextInt(least >= bound) throws IllegalArgumentException
182		*/
183		public void testNextIntBadBounds() {
184	<	try {
185	<	int f = ThreadLocalRandom.current().nextInt(17, 2);
186	<	shouldThrow();
187	<	} catch (IllegalArgumentException success) {}
184	>	int[][] badBoundss = {
185	>	{ 17, 2 },
186	>	{ -42, -42 },
187	>	{ Integer.MAX_VALUE, Integer.MIN_VALUE },
188	>	};
189	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
190	>	for (int[] badBounds : badBoundss) {
191	>	try {
192	>	rnd.nextInt(badBounds[0], badBounds[1]);
193	>	shouldThrow();
194	>	} catch (IllegalArgumentException success) {}
195	>	}
196		}
197
198		/**
#	Line 179 | Line 237 | public class ThreadLocalRandomTest exten
237		}
238
239		/**
240	<	* nextLong(negative) throws IllegalArgumentException
240	>	* nextLong(non-positive) throws IllegalArgumentException
241		*/
242	<	public void testNextLongBoundedNeg() {
243	<	try {
244	<	long f = ThreadLocalRandom.current().nextLong(-17);
245	<	shouldThrow();
246	<	} catch (IllegalArgumentException success) {}
242	>	public void testNextLongBoundNonPositive() {
243	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
244	>	for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
245	>	try {
246	>	rnd.nextLong(bound);
247	>	shouldThrow();
248	>	} catch (IllegalArgumentException success) {}
249	>	}
250		}
251
252		/**
253		* nextLong(least >= bound) throws IllegalArgumentException
254		*/
255		public void testNextLongBadBounds() {
256	<	try {
257	<	long f = ThreadLocalRandom.current().nextLong(17, 2);
258	<	shouldThrow();
259	<	} catch (IllegalArgumentException success) {}
256	>	long[][] badBoundss = {
257	>	{ 17L, 2L },
258	>	{ -42L, -42L },
259	>	{ Long.MAX_VALUE, Long.MIN_VALUE },
260	>	};
261	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
262	>	for (long[] badBounds : badBoundss) {
263	>	try {
264	>	rnd.nextLong(badBounds[0], badBounds[1]);
265	>	shouldThrow();
266	>	} catch (IllegalArgumentException success) {}
267	>	}
268		}
269
270		/**
#	Line 239 | Line 308 | public class ThreadLocalRandomTest exten
308		}
309
310		/**
311	+	* nextDouble(non-positive) throws IllegalArgumentException
312	+	*/
313	+	public void testNextDoubleBoundNonPositive() {
314	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
315	+	double[] badBounds = {
316	+	0.0d,
317	+	-17.0d,
318	+	-Double.MIN_VALUE,
319	+	Double.NEGATIVE_INFINITY,
320	+	Double.NaN,
321	+	};
322	+	for (double bound : badBounds) {
323	+	try {
324	+	rnd.nextDouble(bound);
325	+	shouldThrow();
326	+	} catch (IllegalArgumentException success) {}
327	+	}
328	+	}
329	+
330	+	/**
331		* nextDouble(least, bound) returns least <= value < bound;
332		* repeated calls produce at least two distinct results
333		*/
#	Line 272 | Line 361 | public class ThreadLocalRandomTest exten
361		long firstRand = 0;
362		ThreadLocalRandom firstThreadLocalRandom = null;
363
364	<	final CheckedRunnable getRandomState = new CheckedRunnable() {
364	>	Runnable getRandomState = new CheckedRunnable() {
365		public void realRun() {
366		ThreadLocalRandom current = ThreadLocalRandom.current();
367		assertSame(current, ThreadLocalRandom.current());
#	Line 296 | Line 385 | public class ThreadLocalRandomTest exten
385		fail("all threads generate the same pseudo-random sequence");
386		}
387
299	–	/**
300	–	* Invoking sized ints, long, doubles, with negative sizes throws
301	–	* IllegalArgumentException
302	–	*/
303	–	public void testBadStreamSize() {
304	–	ThreadLocalRandom r = ThreadLocalRandom.current();
305	–	try {
306	–	java.util.stream.IntStream x = r.ints(-1L);
307	–	shouldThrow();
308	–	} catch (IllegalArgumentException success) {}
309	–	try {
310	–	java.util.stream.IntStream x = r.ints(-1L, 2, 3);
311	–	shouldThrow();
312	–	} catch (IllegalArgumentException success) {}
313	–	try {
314	–	java.util.stream.LongStream x = r.longs(-1L);
315	–	shouldThrow();
316	–	} catch (IllegalArgumentException success) {}
317	–	try {
318	–	java.util.stream.LongStream x = r.longs(-1L, -1L, 1L);
319	–	shouldThrow();
320	–	} catch (IllegalArgumentException success) {}
321	–	try {
322	–	java.util.stream.DoubleStream x = r.doubles(-1L);
323	–	shouldThrow();
324	–	} catch (IllegalArgumentException success) {}
325	–	try {
326	–	java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6);
327	–	shouldThrow();
328	–	} catch (IllegalArgumentException success) {}
329	–	}
330	–
331	–	/**
332	–	* Invoking bounded ints, long, doubles, with illegal bounds throws
333	–	* IllegalArgumentException
334	–	*/
335	–	public void testBadStreamBounds() {
336	–	ThreadLocalRandom r = ThreadLocalRandom.current();
337	–	try {
338	–	java.util.stream.IntStream x = r.ints(2, 1);
339	–	shouldThrow();
340	–	} catch (IllegalArgumentException success) {}
341	–	try {
342	–	java.util.stream.IntStream x = r.ints(10, 42, 42);
343	–	shouldThrow();
344	–	} catch (IllegalArgumentException success) {}
345	–	try {
346	–	java.util.stream.LongStream x = r.longs(-1L, -1L);
347	–	shouldThrow();
348	–	} catch (IllegalArgumentException success) {}
349	–	try {
350	–	java.util.stream.LongStream x = r.longs(10, 1L, -2L);
351	–	shouldThrow();
352	–	} catch (IllegalArgumentException success) {}
353	–	try {
354	–	java.util.stream.DoubleStream x = r.doubles(0.0, 0.0);
355	–	shouldThrow();
356	–	} catch (IllegalArgumentException success) {}
357	–	try {
358	–	java.util.stream.DoubleStream x = r.doubles(10, .5, .4);
359	–	shouldThrow();
360	–	} catch (IllegalArgumentException success) {}
361	–	}
362	–
363	–	/**
364	–	* A parallel sized stream of ints generates the given number of values
365	–	*/
366	–	public void testIntsCount() {
367	–	LongAdder counter = new LongAdder();
368	–	ThreadLocalRandom r = ThreadLocalRandom.current();
369	–	long size = 0;
370	–	for (int reps = 0; reps < REPS; ++reps) {
371	–	counter.reset();
372	–	r.ints(size).parallel().forEach(x -> {counter.increment();});
373	–	assertEquals(size, counter.sum());
374	–	size += 524959;
375	–	}
376	–	}
377	–
378	–	/**
379	–	* A parallel sized stream of longs generates the given number of values
380	–	*/
381	–	public void testLongsCount() {
382	–	LongAdder counter = new LongAdder();
383	–	ThreadLocalRandom r = ThreadLocalRandom.current();
384	–	long size = 0;
385	–	for (int reps = 0; reps < REPS; ++reps) {
386	–	counter.reset();
387	–	r.longs(size).parallel().forEach(x -> {counter.increment();});
388	–	assertEquals(size, counter.sum());
389	–	size += 524959;
390	–	}
391	–	}
392	–
393	–	/**
394	–	* A parallel sized stream of doubles generates the given number of values
395	–	*/
396	–	public void testDoublesCount() {
397	–	LongAdder counter = new LongAdder();
398	–	ThreadLocalRandom r = ThreadLocalRandom.current();
399	–	long size = 0;
400	–	for (int reps = 0; reps < REPS; ++reps) {
401	–	counter.reset();
402	–	r.doubles(size).parallel().forEach(x -> {counter.increment();});
403	–	assertEquals(size, counter.sum());
404	–	size += 524959;
405	–	}
406	–	}
407	–
408	–	/**
409	–	* Each of a parallel sized stream of bounded ints is within bounds
410	–	*/
411	–	public void testBoundedInts() {
412	–	AtomicInteger fails = new AtomicInteger(0);
413	–	ThreadLocalRandom r = ThreadLocalRandom.current();
414	–	long size = 12345L;
415	–	for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) {
416	–	for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) {
417	–	final int lo = least, hi = bound;
418	–	r.ints(size, lo, hi).parallel().
419	–	forEach(x -> {if (x < lo || x >= hi)
420	–	fails.getAndIncrement(); });
421	–	}
422	–	}
423	–	assertEquals(0, fails.get());
424	–	}
425	–
426	–	/**
427	–	* Each of a parallel sized stream of bounded longs is within bounds
428	–	*/
429	–	public void testBoundedLongs() {
430	–	AtomicInteger fails = new AtomicInteger(0);
431	–	ThreadLocalRandom r = ThreadLocalRandom.current();
432	–	long size = 123L;
433	–	for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) {
434	–	for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) {
435	–	final long lo = least, hi = bound;
436	–	r.longs(size, lo, hi).parallel().
437	–	forEach(x -> {if (x < lo || x >= hi)
438	–	fails.getAndIncrement(); });
439	–	}
440	–	}
441	–	assertEquals(0, fails.get());
442	–	}
443	–
444	–	/**
445	–	* Each of a parallel sized stream of bounded doubles is within bounds
446	–	*/
447	–	public void testBoundedDoubles() {
448	–	AtomicInteger fails = new AtomicInteger(0);
449	–	ThreadLocalRandom r = ThreadLocalRandom.current();
450	–	long size = 456;
451	–	for (double least = 0.00011; least < 1.0e20; least *= 9) {
452	–	for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) {
453	–	final double lo = least, hi = bound;
454	–	r.doubles(size, lo, hi).parallel().
455	–	forEach(x -> {if (x < lo || x >= hi)
456	–	fails.getAndIncrement(); });
457	–	}
458	–	}
459	–	assertEquals(0, fails.get());
460	–	}
461	–
462	–	/**
463	–	* A parallel unsized stream of ints generates at least 100 values
464	–	*/
465	–	public void testUnsizedIntsCount() {
466	–	LongAdder counter = new LongAdder();
467	–	ThreadLocalRandom r = ThreadLocalRandom.current();
468	–	long size = 100;
469	–	r.ints().limit(size).parallel().forEach(x -> {counter.increment();});
470	–	assertEquals(size, counter.sum());
471	–	}
472	–
473	–	/**
474	–	* A parallel unsized stream of longs generates at least 100 values
475	–	*/
476	–	public void testUnsizedLongsCount() {
477	–	LongAdder counter = new LongAdder();
478	–	ThreadLocalRandom r = ThreadLocalRandom.current();
479	–	long size = 100;
480	–	r.longs().limit(size).parallel().forEach(x -> {counter.increment();});
481	–	assertEquals(size, counter.sum());
482	–	}
483	–
484	–	/**
485	–	* A parallel unsized stream of doubles generates at least 100 values
486	–	*/
487	–	public void testUnsizedDoublesCount() {
488	–	LongAdder counter = new LongAdder();
489	–	ThreadLocalRandom r = ThreadLocalRandom.current();
490	–	long size = 100;
491	–	r.doubles().limit(size).parallel().forEach(x -> {counter.increment();});
492	–	assertEquals(size, counter.sum());
493	–	}
494	–
495	–	/**
496	–	* A sequential unsized stream of ints generates at least 100 values
497	–	*/
498	–	public void testUnsizedIntsCountSeq() {
499	–	LongAdder counter = new LongAdder();
500	–	ThreadLocalRandom r = ThreadLocalRandom.current();
501	–	long size = 100;
502	–	r.ints().limit(size).forEach(x -> {counter.increment();});
503	–	assertEquals(size, counter.sum());
504	–	}
505	–
506	–	/**
507	–	* A sequential unsized stream of longs generates at least 100 values
508	–	*/
509	–	public void testUnsizedLongsCountSeq() {
510	–	LongAdder counter = new LongAdder();
511	–	ThreadLocalRandom r = ThreadLocalRandom.current();
512	–	long size = 100;
513	–	r.longs().limit(size).forEach(x -> {counter.increment();});
514	–	assertEquals(size, counter.sum());
515	–	}
516	–
517	–	/**
518	–	* A sequential unsized stream of doubles generates at least 100 values
519	–	*/
520	–	public void testUnsizedDoublesCountSeq() {
521	–	LongAdder counter = new LongAdder();
522	–	ThreadLocalRandom r = ThreadLocalRandom.current();
523	–	long size = 100;
524	–	r.doubles().limit(size).forEach(x -> {counter.increment();});
525	–	assertEquals(size, counter.sum());
526	–	}
527	–
388		}

Diff Legend

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