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.1 by dl, Fri Jul 31 23:02:50 2009 UTC vs.
Revision 1.24 by jsr166, Sat Dec 10 12:39:15 2016 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6	–	import junit.framework.*;
7	–	import java.util.concurrent.*;
8	–	import java.util.*;
6
7	+	import java.util.concurrent.ThreadLocalRandom;
8	+	import java.util.concurrent.atomic.AtomicLong;
9	+	import java.util.concurrent.atomic.AtomicReference;
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);
20	>	return new TestSuite(ThreadLocalRandomTest.class);
21		}
22
23	<	/**
23	>	/*
24		* Testing coverage notes:
25	<	*
25	>	*
26		* We don't test randomness properties, but only that repeated
27		* calls, up to NCALLS tries, produce at least one different
28		* result.  For bounded versions, we sample various intervals
29		* across multiples of primes.
30		*/
31
32	<	//
32	>	// max numbers of calls to detect getting stuck on one value
33		static final int NCALLS = 10000;
34
35		// max sampled int bound
36		static final int MAX_INT_BOUND = (1 << 28);
37
38	<	// Max sampled long bound
38	>	// max sampled long bound
39		static final long MAX_LONG_BOUND = (1L << 42);
40
41	+	// Number of replications for other checks
42	+	static final int REPS = 20;
43	+
44		/**
45		* setSeed throws UnsupportedOperationException
46		*/
47		public void testSetSeed() {
48		try {
49		ThreadLocalRandom.current().setSeed(17);
50	<	} catch(UnsupportedOperationException success) {
50	>	shouldThrow();
51	>	} catch (UnsupportedOperationException success) {}
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	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
61	>	final java.lang.reflect.Method m;
62	>	try {
63	>	m = ThreadLocalRandom.class.getDeclaredMethod(
64	>	"next", new Class[] { int.class });
65	>	m.setAccessible(true);
66	>	} catch (SecurityException acceptable) {
67	>	// Security manager may deny access
68	>	return;
69	>	} catch (Exception ex) {
70	>	// jdk9 module system may deny access
71	>	if (ex.getClass().getSimpleName()
72	>	.equals("InaccessibleObjectException"))
73	>	return;
74	>	throw ex;
75	>	}
76	>
77	>	int i;
78	>	{
79	>	int val = new java.util.Random().nextInt(4);
80	>	for (i = 0; i < NCALLS; i++) {
81	>	int q = (int) m.invoke(rnd, new Object[] { 2 });
82	>	if (val == q) break;
83	>	}
84	>	assertTrue(i < NCALLS);
85	>	}
86	>
87	>	{
88	>	int r = (int) m.invoke(rnd, new Object[] { 3 });
89	>	for (i = 0; i < NCALLS; i++) {
90	>	int q = (int) m.invoke(rnd, new Object[] { 3 });
91	>	assertTrue(q < (1<<3));
92	>	if (r != q) break;
93	>	}
94	>	assertTrue(i < NCALLS);
95		}
96		}
97
98		/**
99	<	* Repeated calls to nextInt produce at least one different result
99	>	* Repeated calls to nextInt produce at least two distinct results
100		*/
101		public void testNextInt() {
102		int f = ThreadLocalRandom.current().nextInt();
#	Line 57 | Line 107 | public class ThreadLocalRandomTest exten
107		}
108
109		/**
110	<	* Repeated calls to nextLong produce at least one different result
110	>	* Repeated calls to nextLong produce at least two distinct results
111		*/
112		public void testNextLong() {
113		long f = ThreadLocalRandom.current().nextLong();
#	Line 67 | Line 117 | public class ThreadLocalRandomTest exten
117		assertTrue(i < NCALLS);
118		}
119
70	–
120		/**
121	<	* Repeated calls to nextBoolean produce at least one different result
121	>	* Repeated calls to nextBoolean produce at least two distinct results
122		*/
123		public void testNextBoolean() {
124		boolean f = ThreadLocalRandom.current().nextBoolean();
#	Line 80 | Line 129 | public class ThreadLocalRandomTest exten
129		}
130
131		/**
132	<	* Repeated calls to nextFloat produce at least one different result
132	>	* Repeated calls to nextFloat produce at least two distinct results
133		*/
134		public void testNextFloat() {
135		float f = ThreadLocalRandom.current().nextFloat();
#	Line 91 | Line 140 | public class ThreadLocalRandomTest exten
140		}
141
142		/**
143	<	* Repeated calls to nextDouble produce at least one different result
143	>	* Repeated calls to nextDouble produce at least two distinct results
144		*/
145		public void testNextDouble() {
146		double f = ThreadLocalRandom.current().nextDouble();
147	<	double i = 0;
147	>	int i = 0;
148		while (i < NCALLS && ThreadLocalRandom.current().nextDouble() == f)
149		++i;
150		assertTrue(i < NCALLS);
151		}
152
153		/**
154	<	* Repeated calls to nextGaussian produce at least one different result
154	>	* Repeated calls to nextGaussian produce at least two distinct results
155		*/
156		public void testNextGaussian() {
157		double f = ThreadLocalRandom.current().nextGaussian();
#	Line 112 | Line 161 | public class ThreadLocalRandomTest exten
161		assertTrue(i < NCALLS);
162		}
163
115	–
164		/**
165	<	* nextInt(negative) throws IllegalArgumentException;
165	>	* nextInt(non-positive) throws IllegalArgumentException
166		*/
167	<	public void testNextIntBoundedNeg() {
168	<	try {
169	<	int  f = ThreadLocalRandom.current().nextInt(-17);
170	<	} catch(IllegalArgumentException success) {
167	>	public void testNextIntBoundNonPositive() {
168	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
169	>	for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
170	>	try {
171	>	rnd.nextInt(bound);
172	>	shouldThrow();
173	>	} catch (IllegalArgumentException success) {}
174		}
175		}
176
177		/**
178	<	* nextInt(least >= bound) throws IllegalArgumentException;
178	>	* nextInt(least >= bound) throws IllegalArgumentException
179		*/
180		public void testNextIntBadBounds() {
181	<	try {
182	<	int  f = ThreadLocalRandom.current().nextInt(17, 2);
183	<	} catch(IllegalArgumentException success) {
181	>	int[][] badBoundss = {
182	>	{ 17, 2 },
183	>	{ -42, -42 },
184	>	{ Integer.MAX_VALUE, Integer.MIN_VALUE },
185	>	};
186	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
187	>	for (int[] badBounds : badBoundss) {
188	>	try {
189	>	rnd.nextInt(badBounds[0], badBounds[1]);
190	>	shouldThrow();
191	>	} catch (IllegalArgumentException success) {}
192		}
193		}
194
136	–
195		/**
196		* nextInt(bound) returns 0 <= value < bound;
197	<	* repeated calls produce at least one different result
197	>	* repeated calls produce at least two distinct results
198		*/
199		public void testNextIntBounded() {
200		// sample bound space across prime number increments
#	Line 145 | Line 203 | public class ThreadLocalRandomTest exten
203		assertTrue(0 <= f && f < bound);
204		int i = 0;
205		int j;
206	<	while (i < NCALLS &&
206	>	while (i < NCALLS &&
207		(j = ThreadLocalRandom.current().nextInt(bound)) == f) {
208		assertTrue(0 <= j && j < bound);
209		++i;
#	Line 154 | Line 212 | public class ThreadLocalRandomTest exten
212		}
213		}
214
157	–
215		/**
216		* nextInt(least, bound) returns least <= value < bound;
217	<	* repeated calls produce at least one different result
217	>	* repeated calls produce at least two distinct results
218		*/
219		public void testNextIntBounded2() {
220		for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) {
#	Line 166 | Line 223 | public class ThreadLocalRandomTest exten
223		assertTrue(least <= f && f < bound);
224		int i = 0;
225		int j;
226	<	while (i < NCALLS &&
226	>	while (i < NCALLS &&
227		(j = ThreadLocalRandom.current().nextInt(least, bound)) == f) {
228		assertTrue(least <= j && j < bound);
229		++i;
#	Line 177 | Line 234 | public class ThreadLocalRandomTest exten
234		}
235
236		/**
237	<	* nextLong(negative) throws IllegalArgumentException;
237	>	* nextLong(non-positive) throws IllegalArgumentException
238		*/
239	<	public void testNextLongBoundedNeg() {
240	<	try {
241	<	long  f = ThreadLocalRandom.current().nextLong(-17);
242	<	} catch(IllegalArgumentException success) {
239	>	public void testNextLongBoundNonPositive() {
240	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
241	>	for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
242	>	try {
243	>	rnd.nextLong(bound);
244	>	shouldThrow();
245	>	} catch (IllegalArgumentException success) {}
246		}
247		}
248
249		/**
250	<	* nextLong(least >= bound) throws IllegalArgumentException;
250	>	* nextLong(least >= bound) throws IllegalArgumentException
251		*/
252		public void testNextLongBadBounds() {
253	<	try {
254	<	long  f = ThreadLocalRandom.current().nextLong(17, 2);
255	<	} catch(IllegalArgumentException success) {
253	>	long[][] badBoundss = {
254	>	{ 17L, 2L },
255	>	{ -42L, -42L },
256	>	{ Long.MAX_VALUE, Long.MIN_VALUE },
257	>	};
258	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
259	>	for (long[] badBounds : badBoundss) {
260	>	try {
261	>	rnd.nextLong(badBounds[0], badBounds[1]);
262	>	shouldThrow();
263	>	} catch (IllegalArgumentException success) {}
264		}
265		}
266
267		/**
268		* nextLong(bound) returns 0 <= value < bound;
269	<	* repeated calls produce at least one different result
269	>	* repeated calls produce at least two distinct results
270		*/
271		public void testNextLongBounded() {
272		for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) {
#	Line 206 | Line 274 | public class ThreadLocalRandomTest exten
274		assertTrue(0 <= f && f < bound);
275		int i = 0;
276		long j;
277	<	while (i < NCALLS &&
277	>	while (i < NCALLS &&
278		(j = ThreadLocalRandom.current().nextLong(bound)) == f) {
279		assertTrue(0 <= j && j < bound);
280		++i;
#	Line 217 | Line 285 | public class ThreadLocalRandomTest exten
285
286		/**
287		* nextLong(least, bound) returns least <= value < bound;
288	<	* repeated calls produce at least one different result
288	>	* repeated calls produce at least two distinct results
289		*/
290		public void testNextLongBounded2() {
291		for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) {
#	Line 226 | Line 294 | public class ThreadLocalRandomTest exten
294		assertTrue(least <= f && f < bound);
295		int i = 0;
296		long j;
297	<	while (i < NCALLS &&
297	>	while (i < NCALLS &&
298		(j = ThreadLocalRandom.current().nextLong(least, bound)) == f) {
299		assertTrue(least <= j && j < bound);
300		++i;
#	Line 236 | Line 304 | public class ThreadLocalRandomTest exten
304		}
305		}
306
307	+	/**
308	+	* nextDouble(non-positive) throws IllegalArgumentException
309	+	*/
310	+	public void testNextDoubleBoundNonPositive() {
311	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
312	+	double[] badBounds = {
313	+	0.0d,
314	+	-17.0d,
315	+	-Double.MIN_VALUE,
316	+	Double.NEGATIVE_INFINITY,
317	+	Double.NaN,
318	+	};
319	+	for (double bound : badBounds) {
320	+	try {
321	+	rnd.nextDouble(bound);
322	+	shouldThrow();
323	+	} catch (IllegalArgumentException success) {}
324	+	}
325	+	}
326
327		/**
328		* nextDouble(least, bound) returns least <= value < bound;
329	<	* repeated calls produce at least one different result
329	>	* repeated calls produce at least two distinct results
330		*/
331		public void testNextDoubleBounded2() {
332		for (double least = 0.0001; least < 1.0e20; least *= 8) {
#	Line 248 | Line 335 | public class ThreadLocalRandomTest exten
335		assertTrue(least <= f && f < bound);
336		int i = 0;
337		double j;
338	<	while (i < NCALLS &&
338	>	while (i < NCALLS &&
339		(j = ThreadLocalRandom.current().nextDouble(least, bound)) == f) {
340		assertTrue(least <= j && j < bound);
341		++i;
#	Line 258 | Line 345 | public class ThreadLocalRandomTest exten
345		}
346		}
347
348	+	/**
349	+	* Different threads produce different pseudo-random sequences
350	+	*/
351	+	public void testDifferentSequences() {
352	+	// Don't use main thread's ThreadLocalRandom - it is likely to
353	+	// be polluted by previous tests.
354	+	final AtomicReference<ThreadLocalRandom> threadLocalRandom =
355	+	new AtomicReference<ThreadLocalRandom>();
356	+	final AtomicLong rand = new AtomicLong();
357	+
358	+	long firstRand = 0;
359	+	ThreadLocalRandom firstThreadLocalRandom = null;
360	+
361	+	Runnable getRandomState = new CheckedRunnable() {
362	+	public void realRun() {
363	+	ThreadLocalRandom current = ThreadLocalRandom.current();
364	+	assertSame(current, ThreadLocalRandom.current());
365	+	// test bug: the following is not guaranteed and not true in JDK8
366	+	//                assertNotSame(current, threadLocalRandom.get());
367	+	rand.set(current.nextLong());
368	+	threadLocalRandom.set(current);
369	+	}};
370	+
371	+	Thread first = newStartedThread(getRandomState);
372	+	awaitTermination(first);
373	+	firstRand = rand.get();
374	+	firstThreadLocalRandom = threadLocalRandom.get();
375	+
376	+	for (int i = 0; i < NCALLS; i++) {
377	+	Thread t = newStartedThread(getRandomState);
378	+	awaitTermination(t);
379	+	if (firstRand != rand.get())
380	+	return;
381	+	}
382	+	fail("all threads generate the same pseudo-random sequence");
383	+	}
384
385		}

Diff Legend

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