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.30 by jsr166, Wed Aug 12 17:39:43 2020 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("next", int.class);
67	+	m.setAccessible(true);
68	+	} catch (SecurityException acceptable) {
69	+	// Security manager may deny access
70	+	return;
71	+	} catch (Exception ex) {
72	+	// jdk9 module system may deny access
73	+	if (ex.getClass().getSimpleName()
74	+	.equals("InaccessibleObjectException"))
75	+	return;
76	+	throw ex;
77	+	}
78	+
79	+	int i;
80	+	{
81	+	int val = new java.util.Random().nextInt(4);
82	+	for (i = 0; i < NCALLS; i++) {
83	+	int q = (int) m.invoke(rnd, new Object[] { 2 });
84	+	if (val == q) break;
85	+	}
86	+	assertTrue(i < NCALLS);
87	+	}
88	+
89	+	{
90	+	int r = (int) m.invoke(rnd, new Object[] { 3 });
91	+	for (i = 0; i < NCALLS; i++) {
92	+	int q = (int) m.invoke(rnd, new Object[] { 3 });
93	+	assertTrue(q < (1<<3));
94	+	if (r != q) break;
95	+	}
96	+	assertTrue(i < NCALLS);
97	+	}
98	+	}
99	+
100	+	/**
101		* Repeated calls to nextInt produce at least two distinct results
102		*/
103		public void testNextInt() {
#	Line 118 | Line 164 | public class ThreadLocalRandomTest exten
164		}
165
166		/**
167	<	* nextInt(negative) throws IllegalArgumentException
167	>	* nextInt(non-positive) throws IllegalArgumentException
168		*/
169	<	public void testNextIntBoundedNeg() {
170	<	try {
171	<	int f = ThreadLocalRandom.current().nextInt(-17);
172	<	shouldThrow();
173	<	} catch (IllegalArgumentException success) {}
169	>	public void testNextIntBoundNonPositive() {
170	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
171	>	for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
172	>	try {
173	>	rnd.nextInt(bound);
174	>	shouldThrow();
175	>	} catch (IllegalArgumentException success) {}
176	>	}
177		}
178
179		/**
180		* nextInt(least >= bound) throws IllegalArgumentException
181		*/
182		public void testNextIntBadBounds() {
183	<	try {
184	<	int f = ThreadLocalRandom.current().nextInt(17, 2);
185	<	shouldThrow();
186	<	} catch (IllegalArgumentException success) {}
183	>	int[][] badBoundss = {
184	>	{ 17, 2 },
185	>	{ -42, -42 },
186	>	{ Integer.MAX_VALUE, Integer.MIN_VALUE },
187	>	};
188	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
189	>	for (int[] badBounds : badBoundss) {
190	>	try {
191	>	rnd.nextInt(badBounds[0], badBounds[1]);
192	>	shouldThrow();
193	>	} catch (IllegalArgumentException success) {}
194	>	}
195		}
196
197		/**
#	Line 179 | Line 236 | public class ThreadLocalRandomTest exten
236		}
237
238		/**
239	<	* nextLong(negative) throws IllegalArgumentException
239	>	* nextLong(non-positive) throws IllegalArgumentException
240		*/
241	<	public void testNextLongBoundedNeg() {
242	<	try {
243	<	long f = ThreadLocalRandom.current().nextLong(-17);
244	<	shouldThrow();
245	<	} catch (IllegalArgumentException success) {}
241	>	public void testNextLongBoundNonPositive() {
242	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
243	>	for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
244	>	try {
245	>	rnd.nextLong(bound);
246	>	shouldThrow();
247	>	} catch (IllegalArgumentException success) {}
248	>	}
249		}
250
251		/**
252		* nextLong(least >= bound) throws IllegalArgumentException
253		*/
254		public void testNextLongBadBounds() {
255	<	try {
256	<	long f = ThreadLocalRandom.current().nextLong(17, 2);
257	<	shouldThrow();
258	<	} catch (IllegalArgumentException success) {}
255	>	long[][] badBoundss = {
256	>	{ 17L, 2L },
257	>	{ -42L, -42L },
258	>	{ Long.MAX_VALUE, Long.MIN_VALUE },
259	>	};
260	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
261	>	for (long[] badBounds : badBoundss) {
262	>	try {
263	>	rnd.nextLong(badBounds[0], badBounds[1]);
264	>	shouldThrow();
265	>	} catch (IllegalArgumentException success) {}
266	>	}
267		}
268
269		/**
#	Line 239 | Line 307 | public class ThreadLocalRandomTest exten
307		}
308
309		/**
310	+	* nextDouble(non-positive) throws IllegalArgumentException
311	+	*/
312	+	public void testNextDoubleBoundNonPositive() {
313	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
314	+	double[] badBounds = {
315	+	0.0d,
316	+	-17.0d,
317	+	-Double.MIN_VALUE,
318	+	Double.NEGATIVE_INFINITY,
319	+	Double.NaN,
320	+	};
321	+	for (double bound : badBounds) {
322	+	try {
323	+	rnd.nextDouble(bound);
324	+	shouldThrow();
325	+	} catch (IllegalArgumentException success) {}
326	+	}
327	+	}
328	+
329	+	/**
330		* nextDouble(least, bound) returns least <= value < bound;
331		* repeated calls produce at least two distinct results
332		*/
#	Line 266 | Line 354 | public class ThreadLocalRandomTest exten
354		// Don't use main thread's ThreadLocalRandom - it is likely to
355		// be polluted by previous tests.
356		final AtomicReference<ThreadLocalRandom> threadLocalRandom =
357	<	new AtomicReference<ThreadLocalRandom>();
357	>	new AtomicReference<>();
358		final AtomicLong rand = new AtomicLong();
359
360	<	long firstRand = 0;
273	<	ThreadLocalRandom firstThreadLocalRandom = null;
274	<
275	<	final CheckedRunnable getRandomState = new CheckedRunnable() {
360	>	Runnable getRandomState = new CheckedRunnable() {
361		public void realRun() {
362		ThreadLocalRandom current = ThreadLocalRandom.current();
363		assertSame(current, ThreadLocalRandom.current());
279	–	// test bug: the following is not guaranteed and not true in JDK8
280	–	//                assertNotSame(current, threadLocalRandom.get());
364		rand.set(current.nextLong());
365		threadLocalRandom.set(current);
366		}};
367
368	<	Thread first = newStartedThread(getRandomState);
369	<	awaitTermination(first);
370	<	firstRand = rand.get();
371	<	firstThreadLocalRandom = threadLocalRandom.get();
368	>	awaitTermination(newStartedThread(getRandomState));
369	>	long firstRand = rand.get();
370	>	ThreadLocalRandom firstThreadLocalRandom = threadLocalRandom.get();
371	>	assertNotNull(firstThreadLocalRandom);
372
373		for (int i = 0; i < NCALLS; i++) {
374	<	Thread t = newStartedThread(getRandomState);
375	<	awaitTermination(t);
374	>	awaitTermination(newStartedThread(getRandomState));
375	>	if (testImplementationDetails)
376	>	// ThreadLocalRandom has been a singleton since jdk8.
377	>	assertSame(firstThreadLocalRandom, threadLocalRandom.get());
378		if (firstRand != rand.get())
379		return;
380		}
#	Line 297 | Line 382 | public class ThreadLocalRandomTest exten
382		}
383
384		/**
385	<	* 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
385	>	* Repeated calls to nextBytes produce at least values of different signs for every byte
386		*/
387	<	public void testBadStreamBounds() {
388	<	ThreadLocalRandom r = ThreadLocalRandom.current();
389	<	try {
390	<	java.util.stream.IntStream x = r.ints(2, 1);
391	<	shouldThrow();
392	<	} catch (IllegalArgumentException success) {}
393	<	try {
394	<	java.util.stream.IntStream x = r.ints(10, 42, 42);
395	<	shouldThrow();
396	<	} catch (IllegalArgumentException success) {}
397	<	try {
398	<	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(); });
387	>	public void testNextBytes() {
388	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
389	>	int n = rnd.nextInt(1, 20);
390	>	byte[] bytes = new byte[n];
391	>	outer:
392	>	for (int i = 0; i < n; i++) {
393	>	for (int tries = NCALLS; tries-->0; ) {
394	>	byte before = bytes[i];
395	>	rnd.nextBytes(bytes);
396	>	byte after = bytes[i];
397	>	if (after * before < 0)
398	>	continue outer;
399		}
400	+	fail("not enough variation in random bytes");
401		}
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());
402		}
403
404		/**
405	<	* A sequential unsized stream of longs generates at least 100 values
405	>	* Filling an empty array with random bytes succeeds without effect.
406		*/
407	<	public void testUnsizedLongsCountSeq() {
408	<	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());
407	>	public void testNextBytes_emptyArray() {
408	>	ThreadLocalRandom.current().nextBytes(new byte[0]);
409		}
410
411	<	/**
412	<	* A sequential unsized stream of doubles generates at least 100 values
413	<	*/
414	<	public void testUnsizedDoublesCountSeq() {
415	<	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());
411	>	public void testNextBytes_nullArray() {
412	>	try {
413	>	ThreadLocalRandom.current().nextBytes(null);
414	>	shouldThrow();
415	>	} catch (NullPointerException success) {}
416		}
417
418		}

Diff Legend

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