ViewVC Help

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

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

Comparing jsr166/src/test/tck/ForkJoinPool8Test.java (file contents):
Revision 1.23 by jsr166, Sun Sep 22 01:42:44 2013 UTC vs.
Revision 1.39 by jsr166, Mon Jan 8 03:56:32 2018 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9	>	import java.util.HashSet;
10		import java.util.concurrent.CancellationException;
11	+	import java.util.concurrent.CountedCompleter;
12		import java.util.concurrent.ExecutionException;
13		import java.util.concurrent.ForkJoinPool;
14		import java.util.concurrent.ForkJoinTask;
12	–	import java.util.concurrent.ForkJoinWorkerThread;
15		import java.util.concurrent.RecursiveAction;
14	–	import java.util.concurrent.CountedCompleter;
15	–	import java.util.concurrent.ThreadLocalRandom;
16	–	import java.util.concurrent.TimeUnit;
16		import java.util.concurrent.TimeoutException;
17	<	import static java.util.concurrent.TimeUnit.SECONDS;
18	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
19	<	import java.util.Arrays;
21	<	import java.util.HashSet;
17	>
18	>	import junit.framework.Test;
19	>	import junit.framework.TestSuite;
20
21		public class ForkJoinPool8Test extends JSR166TestCase {
22		public static void main(String[] args) {
23	<	junit.textui.TestRunner.run(suite());
23	>	main(suite(), args);
24		}
25
26		public static Test suite() {
#	Line 85 | Line 83 | public class ForkJoinPool8Test extends J
83
84		Thread.currentThread().interrupt();
85		try {
86	<	a.get(5L, SECONDS);
86	>	a.get(randomTimeout(), randomTimeUnit());
87		shouldThrow();
88		} catch (InterruptedException success) {
89		} catch (Throwable fail) { threadUnexpectedException(fail); }
90		}
91
92		try {
93	<	a.get(0L, SECONDS);
93	>	a.get(randomExpiredTimeout(), randomTimeUnit());
94		shouldThrow();
95		} catch (TimeoutException success) {
96		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 110 | Line 108 | public class ForkJoinPool8Test extends J
108		assertFalse(a.cancel(true));
109		try {
110		assertNull(a.get());
111	<	} catch (Throwable fail) { threadUnexpectedException(fail); }
114	<	try {
115	<	assertNull(a.get(5L, SECONDS));
111	>	assertNull(a.get(randomTimeout(), randomTimeUnit()));
112		} catch (Throwable fail) { threadUnexpectedException(fail); }
113		}
114
#	Line 137 | Line 133 | public class ForkJoinPool8Test extends J
133		} catch (Throwable fail) { threadUnexpectedException(fail); }
134
135		try {
136	<	a.get(5L, SECONDS);
136	>	a.get(randomTimeout(), randomTimeUnit());
137		shouldThrow();
138		} catch (CancellationException success) {
139		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 168 | Line 164 | public class ForkJoinPool8Test extends J
164		} catch (Throwable fail) { threadUnexpectedException(fail); }
165
166		try {
167	<	a.get(5L, SECONDS);
167	>	a.get(randomTimeout(), randomTimeUnit());
168		shouldThrow();
169		} catch (ExecutionException success) {
170		assertSame(t.getClass(), success.getCause().getClass());
#	Line 180 | Line 176 | public class ForkJoinPool8Test extends J
176		public FJException(Throwable cause) { super(cause); }
177		}
178
179	<	// A simple recursive action for testing
179	>	/** A simple recursive action for testing. */
180		final class FibAction extends CheckedRecursiveAction {
181		final int number;
182		int result;
#	Line 198 | Line 194 | public class ForkJoinPool8Test extends J
194		}
195		}
196
197	<	// A recursive action failing in base case
197	>	/** A recursive action failing in base case. */
198		static final class FailingFibAction extends RecursiveAction {
199		final int number;
200		int result;
#	Line 270 | Line 266 | public class ForkJoinPool8Test extends J
266		RecursiveAction a = new CheckedRecursiveAction() {
267		protected void realCompute() {
268		FibAction f = new FibAction(8);
269	<	final Thread myself = Thread.currentThread();
269	>	final Thread currentThread = Thread.currentThread();
270
271		// test join()
272		assertSame(f, f.fork());
273	<	myself.interrupt();
278	<	assertTrue(myself.isInterrupted());
273	>	currentThread.interrupt();
274		assertNull(f.join());
275		Thread.interrupted();
276		assertEquals(21, f.result);
#	Line 284 | Line 279 | public class ForkJoinPool8Test extends J
279		f = new FibAction(8);
280		f.cancel(true);
281		assertSame(f, f.fork());
282	<	myself.interrupt();
288	<	assertTrue(myself.isInterrupted());
282	>	currentThread.interrupt();
283		try {
284		f.join();
285		shouldThrow();
#	Line 297 | Line 291 | public class ForkJoinPool8Test extends J
291		f = new FibAction(8);
292		f.completeExceptionally(new FJException());
293		assertSame(f, f.fork());
294	<	myself.interrupt();
301	<	assertTrue(myself.isInterrupted());
294	>	currentThread.interrupt();
295		try {
296		f.join();
297		shouldThrow();
#	Line 310 | Line 303 | public class ForkJoinPool8Test extends J
303		// test quietlyJoin()
304		f = new FibAction(8);
305		assertSame(f, f.fork());
306	<	myself.interrupt();
314	<	assertTrue(myself.isInterrupted());
306	>	currentThread.interrupt();
307		f.quietlyJoin();
308		Thread.interrupted();
309		assertEquals(21, f.result);
#	Line 320 | Line 312 | public class ForkJoinPool8Test extends J
312		f = new FibAction(8);
313		f.cancel(true);
314		assertSame(f, f.fork());
315	<	myself.interrupt();
324	<	assertTrue(myself.isInterrupted());
315	>	currentThread.interrupt();
316		f.quietlyJoin();
317		Thread.interrupted();
318		checkCancelled(f);
#	Line 329 | Line 320 | public class ForkJoinPool8Test extends J
320		f = new FibAction(8);
321		f.completeExceptionally(new FJException());
322		assertSame(f, f.fork());
323	<	myself.interrupt();
333	<	assertTrue(myself.isInterrupted());
323	>	currentThread.interrupt();
324		f.quietlyJoin();
325		Thread.interrupted();
326		checkCompletedAbnormally(f, f.getException());
#	Line 363 | Line 353 | public class ForkJoinPool8Test extends J
353		protected void realCompute() throws Exception {
354		FibAction f = new FibAction(8);
355		assertSame(f, f.fork());
356	<	assertNull(f.get(5L, SECONDS));
356	>	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
357		assertEquals(21, f.result);
358		checkCompletedNormally(f);
359		}};
#	Line 379 | Line 369 | public class ForkJoinPool8Test extends J
369		FibAction f = new FibAction(8);
370		assertSame(f, f.fork());
371		try {
372	<	f.get(5L, null);
372	>	f.get(randomTimeout(), null);
373		shouldThrow();
374		} catch (NullPointerException success) {}
375		}};
#	Line 479 | Line 469 | public class ForkJoinPool8Test extends J
469		FailingFibAction f = new FailingFibAction(8);
470		assertSame(f, f.fork());
471		try {
472	<	f.get(5L, TimeUnit.SECONDS);
472	>	f.get(LONG_DELAY_MS, MILLISECONDS);
473		shouldThrow();
474		} catch (ExecutionException success) {
475		Throwable cause = success.getCause();
#	Line 571 | Line 561 | public class ForkJoinPool8Test extends J
561		assertTrue(f.cancel(true));
562		assertSame(f, f.fork());
563		try {
564	<	f.get(5L, SECONDS);
564	>	f.get(LONG_DELAY_MS, MILLISECONDS);
565		shouldThrow();
566		} catch (CancellationException success) {
567		checkCancelled(f);
#	Line 912 | Line 902 | public class ForkJoinPool8Test extends J
902		}
903		}
904
905	<	// Version of CCF with forced failure in left completions
905	>	/** Version of CCF with forced failure in left completions. */
906		abstract static class FailingCCF extends CountedCompleter {
907		int number;
908		int rnumber;
#	Line 1047 | Line 1037 | public class ForkJoinPool8Test extends J
1037		CCF f = new LCCF(null, 8);
1038		assertSame(f, f.fork());
1039		try {
1040	<	f.get(5L, null);
1040	>	f.get(randomTimeout(), null);
1041		shouldThrow();
1042		} catch (NullPointerException success) {}
1043		}};
#	Line 1490 | Line 1480 | public class ForkJoinPool8Test extends J
1480		*/
1481		public void testAwaitQuiescence1() throws Exception {
1482		final ForkJoinPool p = new ForkJoinPool();
1483	<	try {
1483	>	try (PoolCleaner cleaner = cleaner(p)) {
1484		final long startTime = System.nanoTime();
1485		assertTrue(p.isQuiescent());
1486		ForkJoinTask a = new CheckedRecursiveAction() {
#	Line 1521 | Line 1511 | public class ForkJoinPool8Test extends J
1511		assertFalse(p.isTerminated());
1512		Thread.yield();
1513		}
1524	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1514		assertEquals(0, p.getQueuedTaskCount());
1515		assertFalse(p.getAsyncMode());
1527	–	assertEquals(0, p.getActiveThreadCount());
1528	–	assertEquals(0, p.getQueuedTaskCount());
1516		assertEquals(0, p.getQueuedSubmissionCount());
1517		assertFalse(p.hasQueuedSubmissions());
1518	+	while (p.getActiveThreadCount() != 0
1519	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1520	+	Thread.yield();
1521		assertFalse(p.isShutdown());
1522		assertFalse(p.isTerminating());
1523		assertFalse(p.isTerminated());
1524	<	} finally {
1535	<	joinPool(p);
1524	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1525		}
1526		}
1527
#	Line 1541 | Line 1530 | public class ForkJoinPool8Test extends J
1530		* timeout elapsed
1531		*/
1532		public void testAwaitQuiescence2() throws Exception {
1533	+	/*
1534	+	* """It is possible to disable or limit the use of threads in the
1535	+	* common pool by setting the parallelism property to zero. However
1536	+	* doing so may cause unjoined tasks to never be executed."""
1537	+	*/
1538	+	if ("0".equals(System.getProperty(
1539	+	"java.util.concurrent.ForkJoinPool.common.parallelism")))
1540	+	return;
1541		final ForkJoinPool p = new ForkJoinPool();
1542	<	try {
1542	>	try (PoolCleaner cleaner = cleaner(p)) {
1543		assertTrue(p.isQuiescent());
1544	<	for (;;) {
1545	<	final long startTime = System.nanoTime();
1546	<	ForkJoinTask a = new CheckedRecursiveAction() {
1547	<	protected void realCompute() {
1548	<	FibAction f = new FibAction(8);
1549	<	assertSame(f, f.fork());
1550	<	ForkJoinTask.helpQuiesce();
1551	<	while (!f.isDone()) {
1552	<	assertFalse(p.getAsyncMode());
1553	<	assertFalse(p.isShutdown());
1554	<	assertFalse(p.isTerminating());
1555	<	assertFalse(p.isTerminated());
1556	<	Thread.yield();
1557	<	}
1558	<	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1559	<	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1560	<	assertEquals(21, f.result);
1561	<	}};
1562	<	p.execute(a);
1563	<	if (a.isDone() || p.isQuiescent())
1564	<	continue; // Already done so cannot test; retry
1565	<	while (!p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS)) {
1566	<	assertFalse(p.getAsyncMode());
1567	<	assertFalse(p.isShutdown());
1568	<	assertFalse(p.isTerminating());
1569	<	assertFalse(p.isTerminated());
1570	<	Thread.yield();
1571	<	}
1572	<	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1573	<	assertTrue(p.isQuiescent());
1574	<	assertTrue(a.isDone());
1575	<	assertEquals(0, p.getQueuedTaskCount());
1579	<	assertFalse(p.getAsyncMode());
1580	<	assertEquals(0, p.getActiveThreadCount());
1581	<	assertEquals(0, p.getQueuedTaskCount());
1582	<	assertEquals(0, p.getQueuedSubmissionCount());
1583	<	assertFalse(p.hasQueuedSubmissions());
1584	<	assertFalse(p.isShutdown());
1585	<	assertFalse(p.isTerminating());
1586	<	assertFalse(p.isTerminated());
1587	<	break;
1588	<	}
1589	<	} finally {
1590	<	joinPool(p);
1544	>	final long startTime = System.nanoTime();
1545	>	ForkJoinTask a = new CheckedRecursiveAction() {
1546	>	protected void realCompute() {
1547	>	FibAction f = new FibAction(8);
1548	>	assertSame(f, f.fork());
1549	>	while (!f.isDone()
1550	>	&& millisElapsedSince(startTime) < LONG_DELAY_MS) {
1551	>	assertFalse(p.getAsyncMode());
1552	>	assertFalse(p.isShutdown());
1553	>	assertFalse(p.isTerminating());
1554	>	assertFalse(p.isTerminated());
1555	>	Thread.yield();
1556	>	}
1557	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1558	>	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1559	>	assertEquals(21, f.result);
1560	>	}};
1561	>	p.execute(a);
1562	>	assertTrue(p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS));
1563	>	assertTrue(p.isQuiescent());
1564	>	assertTrue(a.isDone());
1565	>	assertEquals(0, p.getQueuedTaskCount());
1566	>	assertFalse(p.getAsyncMode());
1567	>	assertEquals(0, p.getQueuedSubmissionCount());
1568	>	assertFalse(p.hasQueuedSubmissions());
1569	>	while (p.getActiveThreadCount() != 0
1570	>	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1571	>	Thread.yield();
1572	>	assertFalse(p.isShutdown());
1573	>	assertFalse(p.isTerminating());
1574	>	assertFalse(p.isTerminated());
1575	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1576		}
1577		}
1578

Diff Legend

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