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.5 by jsr166, Sat Nov 21 21:02:14 2009 UTC vs.
Revision 1.14 by jsr166, Sun Jul 14 16:55:01 2013 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.*;
7		import java.util.*;
8	<
8	>	import java.util.concurrent.ThreadLocalRandom;
9	>	import java.util.concurrent.atomic.AtomicLong;
10	>	import java.util.concurrent.atomic.AtomicReference;
11
12		public class ThreadLocalRandomTest extends JSR166TestCase {
13
14		public static void main(String[] args) {
15	<	junit.textui.TestRunner.run (suite());
15	>	junit.textui.TestRunner.run(suite());
16		}
17		public static Test suite() {
18		return new TestSuite(ThreadLocalRandomTest.class);
19		}
20
21	<	/**
21	>	/*
22		* Testing coverage notes:
23		*
24		* We don't test randomness properties, but only that repeated
#	Line 26 | Line 27 | public class ThreadLocalRandomTest exten
27		* across multiples of primes.
28		*/
29
30	<	//
30	>	// max numbers of calls to detect getting stuck on one value
31		static final int NCALLS = 10000;
32
33		// max sampled int bound
34		static final int MAX_INT_BOUND = (1 << 28);
35
36	<	// Max sampled long bound
36	>	// max sampled long bound
37		static final long MAX_LONG_BOUND = (1L << 42);
38
39		/**
#	Line 46 | Line 47 | public class ThreadLocalRandomTest exten
47		}
48
49		/**
50	<	* Repeated calls to nextInt produce at least one different result
50	>	* Repeated calls to nextInt produce at least two distinct results
51		*/
52		public void testNextInt() {
53		int f = ThreadLocalRandom.current().nextInt();
#	Line 57 | Line 58 | public class ThreadLocalRandomTest exten
58		}
59
60		/**
61	<	* Repeated calls to nextLong produce at least one different result
61	>	* Repeated calls to nextLong produce at least two distinct results
62		*/
63		public void testNextLong() {
64		long f = ThreadLocalRandom.current().nextLong();
#	Line 67 | Line 68 | public class ThreadLocalRandomTest exten
68		assertTrue(i < NCALLS);
69		}
70
70	–
71		/**
72	<	* Repeated calls to nextBoolean produce at least one different result
72	>	* Repeated calls to nextBoolean produce at least two distinct results
73		*/
74		public void testNextBoolean() {
75		boolean f = ThreadLocalRandom.current().nextBoolean();
#	Line 80 | Line 80 | public class ThreadLocalRandomTest exten
80		}
81
82		/**
83	<	* Repeated calls to nextFloat produce at least one different result
83	>	* Repeated calls to nextFloat produce at least two distinct results
84		*/
85		public void testNextFloat() {
86		float f = ThreadLocalRandom.current().nextFloat();
#	Line 91 | Line 91 | public class ThreadLocalRandomTest exten
91		}
92
93		/**
94	<	* Repeated calls to nextDouble produce at least one different result
94	>	* Repeated calls to nextDouble produce at least two distinct results
95		*/
96		public void testNextDouble() {
97		double f = ThreadLocalRandom.current().nextDouble();
98	<	double i = 0;
98	>	int i = 0;
99		while (i < NCALLS && ThreadLocalRandom.current().nextDouble() == f)
100		++i;
101		assertTrue(i < NCALLS);
102		}
103
104		/**
105	<	* Repeated calls to nextGaussian produce at least one different result
105	>	* Repeated calls to nextGaussian produce at least two distinct results
106		*/
107		public void testNextGaussian() {
108		double f = ThreadLocalRandom.current().nextGaussian();
#	Line 112 | Line 112 | public class ThreadLocalRandomTest exten
112		assertTrue(i < NCALLS);
113		}
114
115	–
115		/**
116	<	* nextInt(negative) throws IllegalArgumentException;
116	>	* nextInt(negative) throws IllegalArgumentException
117		*/
118		public void testNextIntBoundedNeg() {
119		try {
120	<	int  f = ThreadLocalRandom.current().nextInt(-17);
120	>	int f = ThreadLocalRandom.current().nextInt(-17);
121		shouldThrow();
122		} catch (IllegalArgumentException success) {}
123		}
124
125		/**
126	<	* nextInt(least >= bound) throws IllegalArgumentException;
126	>	* nextInt(least >= bound) throws IllegalArgumentException
127		*/
128		public void testNextIntBadBounds() {
129		try {
130	<	int  f = ThreadLocalRandom.current().nextInt(17, 2);
130	>	int f = ThreadLocalRandom.current().nextInt(17, 2);
131		shouldThrow();
132		} catch (IllegalArgumentException success) {}
133		}
134
136	–
135		/**
136		* nextInt(bound) returns 0 <= value < bound;
137	<	* repeated calls produce at least one different result
137	>	* repeated calls produce at least two distinct results
138		*/
139		public void testNextIntBounded() {
140		// sample bound space across prime number increments
#	Line 154 | Line 152 | public class ThreadLocalRandomTest exten
152		}
153		}
154
157	–
155		/**
156		* nextInt(least, bound) returns least <= value < bound;
157	<	* repeated calls produce at least one different result
157	>	* repeated calls produce at least two distinct results
158		*/
159		public void testNextIntBounded2() {
160		for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) {
#	Line 177 | Line 174 | public class ThreadLocalRandomTest exten
174		}
175
176		/**
177	<	* nextLong(negative) throws IllegalArgumentException;
177	>	* nextLong(negative) throws IllegalArgumentException
178		*/
179		public void testNextLongBoundedNeg() {
180		try {
181	<	long  f = ThreadLocalRandom.current().nextLong(-17);
181	>	long f = ThreadLocalRandom.current().nextLong(-17);
182		shouldThrow();
183		} catch (IllegalArgumentException success) {}
184		}
185
186		/**
187	<	* nextLong(least >= bound) throws IllegalArgumentException;
187	>	* nextLong(least >= bound) throws IllegalArgumentException
188		*/
189		public void testNextLongBadBounds() {
190		try {
191	<	long  f = ThreadLocalRandom.current().nextLong(17, 2);
191	>	long f = ThreadLocalRandom.current().nextLong(17, 2);
192		shouldThrow();
193		} catch (IllegalArgumentException success) {}
194		}
195
196		/**
197		* nextLong(bound) returns 0 <= value < bound;
198	<	* repeated calls produce at least one different result
198	>	* repeated calls produce at least two distinct results
199		*/
200		public void testNextLongBounded() {
201		for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) {
#	Line 217 | Line 214 | public class ThreadLocalRandomTest exten
214
215		/**
216		* nextLong(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 testNextLongBounded2() {
220		for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) {
#	Line 236 | Line 233 | public class ThreadLocalRandomTest exten
233		}
234		}
235
239	–
236		/**
237		* nextDouble(least, bound) returns least <= value < bound;
238	<	* repeated calls produce at least one different result
238	>	* repeated calls produce at least two distinct results
239		*/
240		public void testNextDoubleBounded2() {
241		for (double least = 0.0001; least < 1.0e20; least *= 8) {
#	Line 258 | Line 254 | public class ThreadLocalRandomTest exten
254		}
255		}
256
257	+	/**
258	+	* Different threads produce different pseudo-random sequences
259	+	*/
260	+	public void testDifferentSequences() {
261	+	// Don't use main thread's ThreadLocalRandom - it is likely to
262	+	// be polluted by previous tests.
263	+	final AtomicReference<ThreadLocalRandom> threadLocalRandom =
264	+	new AtomicReference<ThreadLocalRandom>();
265	+	final AtomicLong rand = new AtomicLong();
266	+
267	+	long firstRand = 0;
268	+	ThreadLocalRandom firstThreadLocalRandom = null;
269	+
270	+	final CheckedRunnable getRandomState = new CheckedRunnable() {
271	+	public void realRun() {
272	+	ThreadLocalRandom current = ThreadLocalRandom.current();
273	+	assertSame(current, ThreadLocalRandom.current());
274	+	// test bug: the following is not guaranteed and not true in JDK8
275	+	//                assertNotSame(current, threadLocalRandom.get());
276	+	rand.set(current.nextLong());
277	+	threadLocalRandom.set(current);
278	+	}};
279	+
280	+	Thread first = newStartedThread(getRandomState);
281	+	awaitTermination(first);
282	+	firstRand = rand.get();
283	+	firstThreadLocalRandom = threadLocalRandom.get();
284	+
285	+	for (int i = 0; i < NCALLS; i++) {
286	+	Thread t = newStartedThread(getRandomState);
287	+	awaitTermination(t);
288	+	if (firstRand != rand.get())
289	+	return;
290	+	}
291	+	fail("all threads generate the same pseudo-random sequence");
292	+	}
293
294		}

Diff Legend

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