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.30 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.35 by jsr166, Sat Mar 18 18:20:00 2017 UTC

#	Line 179 | Line 179 | public class ForkJoinPool8Test extends J
179		public FJException(Throwable cause) { super(cause); }
180		}
181
182	<	// A simple recursive action for testing
182	>	/** A simple recursive action for testing. */
183		final class FibAction extends CheckedRecursiveAction {
184		final int number;
185		int result;
#	Line 197 | Line 197 | public class ForkJoinPool8Test extends J
197		}
198		}
199
200	<	// A recursive action failing in base case
200	>	/** A recursive action failing in base case. */
201		static final class FailingFibAction extends RecursiveAction {
202		final int number;
203		int result;
#	Line 269 | Line 269 | public class ForkJoinPool8Test extends J
269		RecursiveAction a = new CheckedRecursiveAction() {
270		protected void realCompute() {
271		FibAction f = new FibAction(8);
272	<	final Thread myself = Thread.currentThread();
272	>	final Thread currentThread = Thread.currentThread();
273
274		// test join()
275		assertSame(f, f.fork());
276	<	myself.interrupt();
277	<	assertTrue(myself.isInterrupted());
276	>	currentThread.interrupt();
277		assertNull(f.join());
278		Thread.interrupted();
279		assertEquals(21, f.result);
#	Line 283 | Line 282 | public class ForkJoinPool8Test extends J
282		f = new FibAction(8);
283		f.cancel(true);
284		assertSame(f, f.fork());
285	<	myself.interrupt();
287	<	assertTrue(myself.isInterrupted());
285	>	currentThread.interrupt();
286		try {
287		f.join();
288		shouldThrow();
#	Line 296 | Line 294 | public class ForkJoinPool8Test extends J
294		f = new FibAction(8);
295		f.completeExceptionally(new FJException());
296		assertSame(f, f.fork());
297	<	myself.interrupt();
300	<	assertTrue(myself.isInterrupted());
297	>	currentThread.interrupt();
298		try {
299		f.join();
300		shouldThrow();
#	Line 309 | Line 306 | public class ForkJoinPool8Test extends J
306		// test quietlyJoin()
307		f = new FibAction(8);
308		assertSame(f, f.fork());
309	<	myself.interrupt();
313	<	assertTrue(myself.isInterrupted());
309	>	currentThread.interrupt();
310		f.quietlyJoin();
311		Thread.interrupted();
312		assertEquals(21, f.result);
#	Line 319 | Line 315 | public class ForkJoinPool8Test extends J
315		f = new FibAction(8);
316		f.cancel(true);
317		assertSame(f, f.fork());
318	<	myself.interrupt();
323	<	assertTrue(myself.isInterrupted());
318	>	currentThread.interrupt();
319		f.quietlyJoin();
320		Thread.interrupted();
321		checkCancelled(f);
#	Line 328 | Line 323 | public class ForkJoinPool8Test extends J
323		f = new FibAction(8);
324		f.completeExceptionally(new FJException());
325		assertSame(f, f.fork());
326	<	myself.interrupt();
332	<	assertTrue(myself.isInterrupted());
326	>	currentThread.interrupt();
327		f.quietlyJoin();
328		Thread.interrupted();
329		checkCompletedAbnormally(f, f.getException());
#	Line 911 | Line 905 | public class ForkJoinPool8Test extends J
905		}
906		}
907
908	<	// Version of CCF with forced failure in left completions
908	>	/** Version of CCF with forced failure in left completions. */
909		abstract static class FailingCCF extends CountedCompleter {
910		int number;
911		int rnumber;
#	Line 1489 | Line 1483 | public class ForkJoinPool8Test extends J
1483		*/
1484		public void testAwaitQuiescence1() throws Exception {
1485		final ForkJoinPool p = new ForkJoinPool();
1486	<	try {
1486	>	try (PoolCleaner cleaner = cleaner(p)) {
1487		final long startTime = System.nanoTime();
1488		assertTrue(p.isQuiescent());
1489		ForkJoinTask a = new CheckedRecursiveAction() {
#	Line 1520 | Line 1514 | public class ForkJoinPool8Test extends J
1514		assertFalse(p.isTerminated());
1515		Thread.yield();
1516		}
1523	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1517		assertEquals(0, p.getQueuedTaskCount());
1518		assertFalse(p.getAsyncMode());
1526	–	assertEquals(0, p.getActiveThreadCount());
1527	–	assertEquals(0, p.getQueuedTaskCount());
1519		assertEquals(0, p.getQueuedSubmissionCount());
1520		assertFalse(p.hasQueuedSubmissions());
1521	+	while (p.getActiveThreadCount() != 0
1522	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1523	+	Thread.yield();
1524		assertFalse(p.isShutdown());
1525		assertFalse(p.isTerminating());
1526		assertFalse(p.isTerminated());
1527	<	} finally {
1534	<	joinPool(p);
1527	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1528		}
1529		}
1530
#	Line 1549 | Line 1542 | public class ForkJoinPool8Test extends J
1542		"java.util.concurrent.ForkJoinPool.common.parallelism")))
1543		return;
1544		final ForkJoinPool p = new ForkJoinPool();
1545	<	try {
1545	>	try (PoolCleaner cleaner = cleaner(p)) {
1546		assertTrue(p.isQuiescent());
1547		final long startTime = System.nanoTime();
1548		ForkJoinTask a = new CheckedRecursiveAction() {
#	Line 1570 | Line 1563 | public class ForkJoinPool8Test extends J
1563		}};
1564		p.execute(a);
1565		assertTrue(p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS));
1573	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1566		assertTrue(p.isQuiescent());
1567		assertTrue(a.isDone());
1568		assertEquals(0, p.getQueuedTaskCount());
1569		assertFalse(p.getAsyncMode());
1578	–	assertEquals(0, p.getActiveThreadCount());
1579	–	assertEquals(0, p.getQueuedTaskCount());
1570		assertEquals(0, p.getQueuedSubmissionCount());
1571		assertFalse(p.hasQueuedSubmissions());
1572	+	while (p.getActiveThreadCount() != 0
1573	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1574	+	Thread.yield();
1575		assertFalse(p.isShutdown());
1576		assertFalse(p.isTerminating());
1577		assertFalse(p.isTerminated());
1578	<	} finally {
1586	<	joinPool(p);
1578	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1579		}
1580		}
1581

Diff Legend

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