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.21 by jsr166, Sat Apr 25 04:55:31 2015 UTC vs.
Revision 1.27 by jsr166, Fri Oct 13 02:34:59 2017 UTC

#	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 338 | Line 385 | public class ThreadLocalRandomTest exten
385		fail("all threads generate the same pseudo-random sequence");
386		}
387
388	+	/**
389	+	* Repeated calls to nextBytes produce at least values of different signs for every byte
390	+	*/
391	+	public void testNextBytes() {
392	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
393	+	int n = rnd.nextInt(1, 20);
394	+	byte[] bytes = new byte[n];
395	+	outer:
396	+	for (int i = 0; i < n; i++) {
397	+	for (int tries = NCALLS; tries-->0; ) {
398	+	byte before = bytes[i];
399	+	rnd.nextBytes(bytes);
400	+	byte after = bytes[i];
401	+	if (after * before < 0)
402	+	continue outer;
403	+	}
404	+	fail("not enough variation in random bytes");
405	+	}
406	+	}
407	+
408	+	/**
409	+	* Filling an empty array with random bytes succeeds without effect.
410	+	*/
411	+	public void testNextBytes_emptyArray() {
412	+	ThreadLocalRandom.current().nextBytes(new byte[0]);
413	+	}
414	+
415	+	public void testNextBytes_nullArray() {
416	+	try {
417	+	ThreadLocalRandom.current().nextBytes(null);
418	+	shouldThrow();
419	+	} catch (NullPointerException success) {}
420	+	}
421	+
422		}

Diff Legend

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