ViewVC Help

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

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

Comparing jsr166/src/test/tck/ForkJoinTaskTest.java (file contents):
Revision 1.14 by jsr166, Mon Sep 13 07:51:18 2010 UTC vs.
Revision 1.59 by jsr166, Fri Dec 4 20:29:22 2020 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 java.util.concurrent.ExecutionException;
6	>
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9	>	import java.util.Arrays;
10	>	import java.util.HashSet;
11	>	import java.util.concurrent.Callable;
12		import java.util.concurrent.CancellationException;
13	+	import java.util.concurrent.ExecutionException;
14		import java.util.concurrent.ForkJoinPool;
15		import java.util.concurrent.ForkJoinTask;
10	–	import java.util.concurrent.ForkJoinWorkerThread;
16		import java.util.concurrent.RecursiveAction;
17	<	import java.util.concurrent.TimeUnit;
18	<	import java.util.concurrent.atomic.*;
19	<	import java.util.*;
20	<	import junit.framework.*;
17	>	import java.util.concurrent.TimeoutException;
18	>	import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
19	>
20	>	import junit.framework.Test;
21	>	import junit.framework.TestSuite;
22
23		public class ForkJoinTaskTest extends JSR166TestCase {
24
25		public static void main(String[] args) {
26	<	junit.textui.TestRunner.run(suite());
26	>	main(suite(), args);
27		}
28
29		public static Test suite() {
30		return new TestSuite(ForkJoinTaskTest.class);
31		}
32
33	+	// Runs with "mainPool" use > 1 thread. singletonPool tests use 1
34	+	static final int mainPoolSize =
35	+	Math.max(2, Runtime.getRuntime().availableProcessors());
36	+
37		private static ForkJoinPool mainPool() {
38	<	return new ForkJoinPool();
38	>	return new ForkJoinPool(mainPoolSize);
39		}
40
41		private static ForkJoinPool singletonPool() {
#	Line 39 | Line 49 | public class ForkJoinTaskTest extends JS
49		}
50
51		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
52	+	try (PoolCleaner cleaner = cleaner(pool)) {
53	+	assertFalse(a.isDone());
54	+	assertFalse(a.isCompletedNormally());
55	+	assertFalse(a.isCompletedAbnormally());
56	+	assertFalse(a.isCancelled());
57	+	assertNull(a.getException());
58	+	assertNull(a.getRawResult());
59	+
60	+	assertNull(pool.invoke(a));
61	+
62	+	assertTrue(a.isDone());
63	+	assertTrue(a.isCompletedNormally());
64	+	assertFalse(a.isCompletedAbnormally());
65	+	assertFalse(a.isCancelled());
66	+	assertNull(a.getException());
67	+	assertNull(a.getRawResult());
68	+	}
69	+	}
70	+
71	+	void checkNotDone(ForkJoinTask a) {
72	+	assertFalse(a.isDone());
73	+	assertFalse(a.isCompletedNormally());
74	+	assertFalse(a.isCompletedAbnormally());
75	+	assertFalse(a.isCancelled());
76	+	assertNull(a.getException());
77	+	assertNull(a.getRawResult());
78	+
79	+	try {
80	+	a.get(randomExpiredTimeout(), randomTimeUnit());
81	+	shouldThrow();
82	+	} catch (TimeoutException success) {
83	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
84	+	}
85	+
86	+	<T> void checkCompletedNormally(ForkJoinTask<T> a) {
87	+	checkCompletedNormally(a, null);
88	+	}
89	+
90	+	<T> void checkCompletedNormally(ForkJoinTask<T> a, T expectedValue) {
91	+	assertTrue(a.isDone());
92	+	assertFalse(a.isCancelled());
93	+	assertTrue(a.isCompletedNormally());
94	+	assertFalse(a.isCompletedAbnormally());
95	+	assertNull(a.getException());
96	+	assertSame(expectedValue, a.getRawResult());
97	+
98	+	{
99	+	Thread.currentThread().interrupt();
100	+	long startTime = System.nanoTime();
101	+	assertSame(expectedValue, a.join());
102	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
103	+	Thread.interrupted();
104	+	}
105	+
106	+	{
107	+	Thread.currentThread().interrupt();
108	+	long startTime = System.nanoTime();
109	+	a.quietlyJoin();        // should be no-op
110	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
111	+	Thread.interrupted();
112	+	}
113	+
114	+	assertFalse(a.cancel(false));
115	+	assertFalse(a.cancel(true));
116	+
117	+	T v1 = null, v2 = null;
118	+	try {
119	+	v1 = a.get();
120	+	v2 = a.get(randomTimeout(), randomTimeUnit());
121	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
122	+	assertSame(expectedValue, v1);
123	+	assertSame(expectedValue, v2);
124	+	}
125	+
126	+	void checkCancelled(ForkJoinTask a) {
127	+	assertTrue(a.isDone());
128	+	assertTrue(a.isCancelled());
129	+	assertFalse(a.isCompletedNormally());
130	+	assertTrue(a.isCompletedAbnormally());
131	+	assertTrue(a.getException() instanceof CancellationException);
132	+	assertNull(a.getRawResult());
133	+	assertTrue(a.cancel(false));
134	+	assertTrue(a.cancel(true));
135	+
136	+	try {
137	+	Thread.currentThread().interrupt();
138	+	a.join();
139	+	shouldThrow();
140	+	} catch (CancellationException success) {
141	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
142	+	Thread.interrupted();
143	+
144	+	{
145	+	long startTime = System.nanoTime();
146	+	a.quietlyJoin();        // should be no-op
147	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
148	+	}
149	+
150	+	try {
151	+	a.get();
152	+	shouldThrow();
153	+	} catch (CancellationException success) {
154	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
155	+
156		try {
157	<	assertTrue(pool.invoke(a) == null);
158	<	} finally {
159	<	joinPool(pool);
157	>	a.get(randomTimeout(), randomTimeUnit());
158	>	shouldThrow();
159	>	} catch (CancellationException success) {
160	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
161	>	}
162	>
163	>	void checkCompletedAbnormally(ForkJoinTask a, Throwable t) {
164	>	assertTrue(a.isDone());
165	>	assertFalse(a.isCancelled());
166	>	assertFalse(a.isCompletedNormally());
167	>	assertTrue(a.isCompletedAbnormally());
168	>	assertSame(t.getClass(), a.getException().getClass());
169	>	assertNull(a.getRawResult());
170	>	assertFalse(a.cancel(false));
171	>	assertFalse(a.cancel(true));
172	>
173	>	try {
174	>	Thread.currentThread().interrupt();
175	>	a.join();
176	>	shouldThrow();
177	>	} catch (Throwable expected) {
178	>	assertSame(t.getClass(), expected.getClass());
179	>	}
180	>	Thread.interrupted();
181	>
182	>	{
183	>	long startTime = System.nanoTime();
184	>	a.quietlyJoin();        // should be no-op
185	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
186		}
187	+
188	+	try {
189	+	a.get();
190	+	shouldThrow();
191	+	} catch (ExecutionException success) {
192	+	assertSame(t.getClass(), success.getCause().getClass());
193	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
194	+
195	+	try {
196	+	a.get(randomTimeout(), randomTimeUnit());
197	+	shouldThrow();
198	+	} catch (ExecutionException success) {
199	+	assertSame(t.getClass(), success.getCause().getClass());
200	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
201		}
202
203		/*
#	Line 54 | Line 208 | public class ForkJoinTaskTest extends JS
208		* differently than supplied Recursive forms.
209		*/
210
211	<	static final class FJException extends RuntimeException {
211	>	public static final class FJException extends RuntimeException {
212		FJException() { super(); }
213		}
214
215	<	static abstract class BinaryAsyncAction extends ForkJoinTask<Void> {
215	>	abstract static class BinaryAsyncAction extends ForkJoinTask<Void> {
216		private volatile int controlState;
217
218		static final AtomicIntegerFieldUpdater<BinaryAsyncAction> controlStateUpdater =
219		AtomicIntegerFieldUpdater.newUpdater(BinaryAsyncAction.class,
220		"controlState");
221
222	<	private BinaryAsyncAction parent;
222	>	private volatile BinaryAsyncAction parent;
223
224	<	private BinaryAsyncAction sibling;
224	>	private volatile BinaryAsyncAction sibling;
225
226		protected BinaryAsyncAction() {
227		}
#	Line 102 | Line 256 | public class ForkJoinTaskTest extends JS
256		super.completeExceptionally(ex);
257		}
258
259	+	public boolean cancel(boolean mayInterruptIfRunning) {
260	+	if (super.cancel(mayInterruptIfRunning)) {
261	+	completeExceptionally(new FJException());
262	+	return true;
263	+	}
264	+	return false;
265	+	}
266	+
267		public final void complete() {
268		BinaryAsyncAction a = this;
269		for (;;) {
#	Line 123 | Line 285 | public class ForkJoinTaskTest extends JS
285		}
286
287		public final void completeExceptionally(Throwable ex) {
288	<	BinaryAsyncAction a = this;
127	<	while (!a.isCompletedAbnormally()) {
288	>	for (BinaryAsyncAction a = this;;) {
289		a.completeThisExceptionally(ex);
290		BinaryAsyncAction s = a.sibling;
291	<	if (s != null)
292	<	s.cancel(false);
293	<	if (!a.onException() || (a = a.parent) == null)
291	>	if (s != null && !s.isDone())
292	>	s.completeExceptionally(ex);
293	>	if ((a = a.parent) == null)
294		break;
295		}
296		}
#	Line 179 | Line 340 | public class ForkJoinTaskTest extends JS
340		public final boolean exec() {
341		AsyncFib f = this;
342		int n = f.number;
343	<	if (n > 1) {
344	<	while (n > 1) {
345	<	AsyncFib p = f;
346	<	AsyncFib r = new AsyncFib(n - 2);
347	<	f = new AsyncFib(--n);
348	<	p.linkSubtasks(r, f);
188	<	r.fork();
189	<	}
190	<	f.number = n;
343	>	while (n > 1) {
344	>	AsyncFib p = f;
345	>	AsyncFib r = new AsyncFib(n - 2);
346	>	f = new AsyncFib(--n);
347	>	p.linkSubtasks(r, f);
348	>	r.fork();
349		}
350		f.complete();
351		return false;
#	Line 198 | Line 356 | public class ForkJoinTaskTest extends JS
356		}
357		}
358
201	–
359		static final class FailingAsyncFib extends BinaryAsyncAction {
360		int number;
361		public FailingAsyncFib(int n) {
#	Line 208 | Line 365 | public class ForkJoinTaskTest extends JS
365		public final boolean exec() {
366		FailingAsyncFib f = this;
367		int n = f.number;
368	<	if (n > 1) {
369	<	while (n > 1) {
370	<	FailingAsyncFib p = f;
371	<	FailingAsyncFib r = new FailingAsyncFib(n - 2);
372	<	f = new FailingAsyncFib(--n);
373	<	p.linkSubtasks(r, f);
217	<	r.fork();
218	<	}
219	<	f.number = n;
368	>	while (n > 1) {
369	>	FailingAsyncFib p = f;
370	>	FailingAsyncFib r = new FailingAsyncFib(n - 2);
371	>	f = new FailingAsyncFib(--n);
372	>	p.linkSubtasks(r, f);
373	>	r.fork();
374		}
375		f.complete();
376		return false;
#	Line 230 | Line 384 | public class ForkJoinTaskTest extends JS
384		/**
385		* invoke returns when task completes normally.
386		* isCompletedAbnormally and isCancelled return false for normally
387	<	* completed tasks. getRawResult of a RecursiveAction returns null;
387	>	* completed tasks; getRawResult returns null.
388		*/
389		public void testInvoke() {
390	<	RecursiveAction a = new RecursiveAction() {
391	<	public void compute() {
390	>	RecursiveAction a = new CheckedRecursiveAction() {
391	>	protected void realCompute() {
392		AsyncFib f = new AsyncFib(8);
393	<	f.invoke();
394	<	threadAssertTrue(f.number == 21);
395	<	threadAssertTrue(f.isDone());
242	<	threadAssertFalse(f.isCancelled());
243	<	threadAssertFalse(f.isCompletedAbnormally());
244	<	threadAssertTrue(f.getRawResult() == null);
393	>	assertNull(f.invoke());
394	>	assertEquals(21, f.number);
395	>	checkCompletedNormally(f);
396		}};
397		testInvokeOnPool(mainPool(), a);
398		}
#	Line 252 | Line 403 | public class ForkJoinTaskTest extends JS
403		* completed tasks
404		*/
405		public void testQuietlyInvoke() {
406	<	RecursiveAction a = new RecursiveAction() {
407	<	public void compute() {
406	>	RecursiveAction a = new CheckedRecursiveAction() {
407	>	protected void realCompute() {
408		AsyncFib f = new AsyncFib(8);
409		f.quietlyInvoke();
410	<	threadAssertTrue(f.number == 21);
411	<	threadAssertTrue(f.isDone());
261	<	threadAssertFalse(f.isCancelled());
262	<	threadAssertFalse(f.isCompletedAbnormally());
263	<	threadAssertTrue(f.getRawResult() == null);
410	>	assertEquals(21, f.number);
411	>	checkCompletedNormally(f);
412		}};
413		testInvokeOnPool(mainPool(), a);
414		}
#	Line 269 | Line 417 | public class ForkJoinTaskTest extends JS
417		* join of a forked task returns when task completes
418		*/
419		public void testForkJoin() {
420	<	RecursiveAction a = new RecursiveAction() {
421	<	public void compute() {
420	>	RecursiveAction a = new CheckedRecursiveAction() {
421	>	protected void realCompute() {
422		AsyncFib f = new AsyncFib(8);
423	<	f.fork();
424	<	f.join();
425	<	threadAssertTrue(f.number == 21);
426	<	threadAssertTrue(f.isDone());
279	<	threadAssertTrue(f.getRawResult() == null);
423	>	assertSame(f, f.fork());
424	>	assertNull(f.join());
425	>	assertEquals(21, f.number);
426	>	checkCompletedNormally(f);
427		}};
428		testInvokeOnPool(mainPool(), a);
429		}
#	Line 285 | Line 432 | public class ForkJoinTaskTest extends JS
432		* get of a forked task returns when task completes
433		*/
434		public void testForkGet() {
435	<	RecursiveAction a = new RecursiveAction() {
436	<	public void compute() {
437	<	try {
438	<	AsyncFib f = new AsyncFib(8);
439	<	f.fork();
440	<	f.get();
441	<	threadAssertTrue(f.number == 21);
295	<	threadAssertTrue(f.isDone());
296	<	} catch (Exception ex) {
297	<	unexpectedException(ex);
298	<	}
435	>	RecursiveAction a = new CheckedRecursiveAction() {
436	>	protected void realCompute() throws Exception {
437	>	AsyncFib f = new AsyncFib(8);
438	>	assertSame(f, f.fork());
439	>	assertNull(f.get());
440	>	assertEquals(21, f.number);
441	>	checkCompletedNormally(f);
442		}};
443		testInvokeOnPool(mainPool(), a);
444		}
#	Line 304 | Line 447 | public class ForkJoinTaskTest extends JS
447		* timed get of a forked task returns when task completes
448		*/
449		public void testForkTimedGet() {
450	<	RecursiveAction a = new RecursiveAction() {
451	<	public void compute() {
452	<	try {
453	<	AsyncFib f = new AsyncFib(8);
454	<	f.fork();
455	<	f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
456	<	threadAssertTrue(f.number == 21);
314	<	threadAssertTrue(f.isDone());
315	<	} catch (Exception ex) {
316	<	unexpectedException(ex);
317	<	}
450	>	RecursiveAction a = new CheckedRecursiveAction() {
451	>	protected void realCompute() throws Exception {
452	>	AsyncFib f = new AsyncFib(8);
453	>	assertSame(f, f.fork());
454	>	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
455	>	assertEquals(21, f.number);
456	>	checkCompletedNormally(f);
457		}};
458		testInvokeOnPool(mainPool(), a);
459		}
#	Line 323 | Line 462 | public class ForkJoinTaskTest extends JS
462		* timed get with null time unit throws NPE
463		*/
464		public void testForkTimedGetNPE() {
465	<	RecursiveAction a = new RecursiveAction() {
466	<	public void compute() {
465	>	RecursiveAction a = new CheckedRecursiveAction() {
466	>	protected void realCompute() throws Exception {
467	>	AsyncFib f = new AsyncFib(8);
468	>	assertSame(f, f.fork());
469		try {
470	<	AsyncFib f = new AsyncFib(8);
330	<	f.fork();
331	<	f.get(5L, null);
470	>	f.get(randomTimeout(), null);
471		shouldThrow();
472	<	} catch (NullPointerException success) {
334	<	} catch (Exception ex) {
335	<	unexpectedException(ex);
336	<	}
472	>	} catch (NullPointerException success) {}
473		}};
474		testInvokeOnPool(mainPool(), a);
475		}
#	Line 342 | Line 478 | public class ForkJoinTaskTest extends JS
478		* quietlyJoin of a forked task returns when task completes
479		*/
480		public void testForkQuietlyJoin() {
481	<	RecursiveAction a = new RecursiveAction() {
482	<	public void compute() {
481	>	RecursiveAction a = new CheckedRecursiveAction() {
482	>	protected void realCompute() {
483		AsyncFib f = new AsyncFib(8);
484	<	f.fork();
484	>	assertSame(f, f.fork());
485		f.quietlyJoin();
486	<	threadAssertTrue(f.number == 21);
487	<	threadAssertTrue(f.isDone());
486	>	assertEquals(21, f.number);
487	>	checkCompletedNormally(f);
488		}};
489		testInvokeOnPool(mainPool(), a);
490		}
491
356	–
492		/**
493		* helpQuiesce returns when tasks are complete.
494		* getQueuedTaskCount returns 0 when quiescent
495		*/
496		public void testForkHelpQuiesce() {
497	<	RecursiveAction a = new RecursiveAction() {
498	<	public void compute() {
497	>	RecursiveAction a = new CheckedRecursiveAction() {
498	>	protected void realCompute() {
499		AsyncFib f = new AsyncFib(8);
500	<	f.fork();
501	<	f.helpQuiesce();
502	<	threadAssertTrue(f.number == 21);
503	<	threadAssertTrue(f.isDone());
504	<	threadAssertTrue(getQueuedTaskCount() == 0);
500	>	assertSame(f, f.fork());
501	>	helpQuiesce();
502	>	while (!f.isDone()) // wait out race
503	>	;
504	>	assertEquals(21, f.number);
505	>	assertEquals(0, getQueuedTaskCount());
506	>	checkCompletedNormally(f);
507		}};
508		testInvokeOnPool(mainPool(), a);
509		}
510
374	–
511		/**
512		* invoke task throws exception when task completes abnormally
513		*/
514		public void testAbnormalInvoke() {
515	<	RecursiveAction a = new RecursiveAction() {
516	<	public void compute() {
515	>	RecursiveAction a = new CheckedRecursiveAction() {
516	>	protected void realCompute() {
517	>	FailingAsyncFib f = new FailingAsyncFib(8);
518		try {
382	–	FailingAsyncFib f = new FailingAsyncFib(8);
519		f.invoke();
520		shouldThrow();
521		} catch (FJException success) {
522	+	checkCompletedAbnormally(f, success);
523		}
524		}};
525		testInvokeOnPool(mainPool(), a);
#	Line 392 | Line 529 | public class ForkJoinTaskTest extends JS
529		* quietlyInvoke task returns when task completes abnormally
530		*/
531		public void testAbnormalQuietlyInvoke() {
532	<	RecursiveAction a = new RecursiveAction() {
533	<	public void compute() {
532	>	RecursiveAction a = new CheckedRecursiveAction() {
533	>	protected void realCompute() {
534		FailingAsyncFib f = new FailingAsyncFib(8);
535		f.quietlyInvoke();
536	<	threadAssertTrue(f.isDone());
536	>	assertTrue(f.getException() instanceof FJException);
537	>	checkCompletedAbnormally(f, f.getException());
538		}};
539		testInvokeOnPool(mainPool(), a);
540		}
#	Line 405 | Line 543 | public class ForkJoinTaskTest extends JS
543		* join of a forked task throws exception when task completes abnormally
544		*/
545		public void testAbnormalForkJoin() {
546	<	RecursiveAction a = new RecursiveAction() {
547	<	public void compute() {
546	>	RecursiveAction a = new CheckedRecursiveAction() {
547	>	protected void realCompute() {
548	>	FailingAsyncFib f = new FailingAsyncFib(8);
549	>	assertSame(f, f.fork());
550		try {
411	–	FailingAsyncFib f = new FailingAsyncFib(8);
412	–	f.fork();
551		f.join();
552		shouldThrow();
553		} catch (FJException success) {
554	+	checkCompletedAbnormally(f, success);
555		}
556		}};
557		testInvokeOnPool(mainPool(), a);
#	Line 422 | Line 561 | public class ForkJoinTaskTest extends JS
561		* get of a forked task throws exception when task completes abnormally
562		*/
563		public void testAbnormalForkGet() {
564	<	RecursiveAction a = new RecursiveAction() {
565	<	public void compute() {
564	>	RecursiveAction a = new CheckedRecursiveAction() {
565	>	protected void realCompute() throws Exception {
566	>	FailingAsyncFib f = new FailingAsyncFib(8);
567	>	assertSame(f, f.fork());
568		try {
428	–	FailingAsyncFib f = new FailingAsyncFib(8);
429	–	f.fork();
569		f.get();
570		shouldThrow();
571		} catch (ExecutionException success) {
572	<	} catch (Exception ex) {
573	<	unexpectedException(ex);
572	>	Throwable cause = success.getCause();
573	>	assertTrue(cause instanceof FJException);
574	>	checkCompletedAbnormally(f, cause);
575		}
576		}};
577		testInvokeOnPool(mainPool(), a);
#	Line 441 | Line 581 | public class ForkJoinTaskTest extends JS
581		* timed get of a forked task throws exception when task completes abnormally
582		*/
583		public void testAbnormalForkTimedGet() {
584	<	RecursiveAction a = new RecursiveAction() {
585	<	public void compute() {
584	>	RecursiveAction a = new CheckedRecursiveAction() {
585	>	protected void realCompute() throws Exception {
586	>	FailingAsyncFib f = new FailingAsyncFib(8);
587	>	assertSame(f, f.fork());
588		try {
589	<	FailingAsyncFib f = new FailingAsyncFib(8);
448	<	f.fork();
449	<	f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
589	>	f.get(LONG_DELAY_MS, MILLISECONDS);
590		shouldThrow();
591		} catch (ExecutionException success) {
592	<	} catch (Exception ex) {
593	<	unexpectedException(ex);
592	>	Throwable cause = success.getCause();
593	>	assertTrue(cause instanceof FJException);
594	>	checkCompletedAbnormally(f, cause);
595		}
596		}};
597		testInvokeOnPool(mainPool(), a);
#	Line 460 | Line 601 | public class ForkJoinTaskTest extends JS
601		* quietlyJoin of a forked task returns when task completes abnormally
602		*/
603		public void testAbnormalForkQuietlyJoin() {
604	<	RecursiveAction a = new RecursiveAction() {
605	<	public void compute() {
604	>	RecursiveAction a = new CheckedRecursiveAction() {
605	>	protected void realCompute() {
606		FailingAsyncFib f = new FailingAsyncFib(8);
607	<	f.fork();
607	>	assertSame(f, f.fork());
608		f.quietlyJoin();
609	<	threadAssertTrue(f.isDone());
610	<	threadAssertTrue(f.isCompletedAbnormally());
470	<	threadAssertTrue(f.getException() instanceof FJException);
609	>	assertTrue(f.getException() instanceof FJException);
610	>	checkCompletedAbnormally(f, f.getException());
611		}};
612		testInvokeOnPool(mainPool(), a);
613		}
#	Line 476 | Line 616 | public class ForkJoinTaskTest extends JS
616		* invoke task throws exception when task cancelled
617		*/
618		public void testCancelledInvoke() {
619	<	RecursiveAction a = new RecursiveAction() {
620	<	public void compute() {
619	>	RecursiveAction a = new CheckedRecursiveAction() {
620	>	protected void realCompute() {
621	>	AsyncFib f = new AsyncFib(8);
622	>	assertTrue(f.cancel(true));
623		try {
482	–	AsyncFib f = new AsyncFib(8);
483	–	f.cancel(true);
624		f.invoke();
625		shouldThrow();
626		} catch (CancellationException success) {
627	+	checkCancelled(f);
628		}
629		}};
630		testInvokeOnPool(mainPool(), a);
#	Line 493 | Line 634 | public class ForkJoinTaskTest extends JS
634		* join of a forked task throws exception when task cancelled
635		*/
636		public void testCancelledForkJoin() {
637	<	RecursiveAction a = new RecursiveAction() {
638	<	public void compute() {
637	>	RecursiveAction a = new CheckedRecursiveAction() {
638	>	protected void realCompute() {
639	>	AsyncFib f = new AsyncFib(8);
640	>	assertTrue(f.cancel(true));
641	>	assertSame(f, f.fork());
642		try {
499	–	AsyncFib f = new AsyncFib(8);
500	–	f.cancel(true);
501	–	f.fork();
643		f.join();
644		shouldThrow();
645		} catch (CancellationException success) {
646	+	checkCancelled(f);
647		}
648		}};
649		testInvokeOnPool(mainPool(), a);
#	Line 511 | Line 653 | public class ForkJoinTaskTest extends JS
653		* get of a forked task throws exception when task cancelled
654		*/
655		public void testCancelledForkGet() {
656	<	RecursiveAction a = new RecursiveAction() {
657	<	public void compute() {
656	>	RecursiveAction a = new CheckedRecursiveAction() {
657	>	protected void realCompute() throws Exception {
658	>	AsyncFib f = new AsyncFib(8);
659	>	assertTrue(f.cancel(true));
660	>	assertSame(f, f.fork());
661		try {
517	–	AsyncFib f = new AsyncFib(8);
518	–	f.cancel(true);
519	–	f.fork();
662		f.get();
663		shouldThrow();
664		} catch (CancellationException success) {
665	<	} catch (Exception ex) {
524	<	unexpectedException(ex);
665	>	checkCancelled(f);
666		}
667		}};
668		testInvokeOnPool(mainPool(), a);
#	Line 530 | Line 671 | public class ForkJoinTaskTest extends JS
671		/**
672		* timed get of a forked task throws exception when task cancelled
673		*/
674	<	public void testCancelledForkTimedGet() {
675	<	RecursiveAction a = new RecursiveAction() {
676	<	public void compute() {
674	>	public void testCancelledForkTimedGet() throws Exception {
675	>	RecursiveAction a = new CheckedRecursiveAction() {
676	>	protected void realCompute() throws Exception {
677	>	AsyncFib f = new AsyncFib(8);
678	>	assertTrue(f.cancel(true));
679	>	assertSame(f, f.fork());
680		try {
681	<	AsyncFib f = new AsyncFib(8);
538	<	f.cancel(true);
539	<	f.fork();
540	<	f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
681	>	f.get(LONG_DELAY_MS, MILLISECONDS);
682		shouldThrow();
683		} catch (CancellationException success) {
684	<	} catch (Exception ex) {
544	<	unexpectedException(ex);
684	>	checkCancelled(f);
685		}
686		}};
687		testInvokeOnPool(mainPool(), a);
#	Line 551 | Line 691 | public class ForkJoinTaskTest extends JS
691		* quietlyJoin of a forked task returns when task cancelled
692		*/
693		public void testCancelledForkQuietlyJoin() {
694	<	RecursiveAction a = new RecursiveAction() {
695	<	public void compute() {
694	>	RecursiveAction a = new CheckedRecursiveAction() {
695	>	protected void realCompute() {
696		AsyncFib f = new AsyncFib(8);
697	<	f.cancel(true);
698	<	f.fork();
697	>	assertTrue(f.cancel(true));
698	>	assertSame(f, f.fork());
699		f.quietlyJoin();
700	<	threadAssertTrue(f.isDone());
561	<	threadAssertTrue(f.isCompletedAbnormally());
562	<	threadAssertTrue(f.getException() instanceof CancellationException);
700	>	checkCancelled(f);
701		}};
702		testInvokeOnPool(mainPool(), a);
703		}
#	Line 569 | Line 707 | public class ForkJoinTaskTest extends JS
707		*/
708		public void testGetPool() {
709		final ForkJoinPool mainPool = mainPool();
710	<	RecursiveAction a = new RecursiveAction() {
711	<	public void compute() {
712	<	threadAssertTrue(getPool() == mainPool);
710	>	RecursiveAction a = new CheckedRecursiveAction() {
711	>	protected void realCompute() {
712	>	assertSame(mainPool, getPool());
713		}};
714		testInvokeOnPool(mainPool, a);
715		}
#	Line 580 | Line 718 | public class ForkJoinTaskTest extends JS
718		* getPool of non-FJ task returns null
719		*/
720		public void testGetPool2() {
721	<	RecursiveAction a = new RecursiveAction() {
722	<	public void compute() {
723	<	threadAssertTrue(getPool() == null);
721	>	RecursiveAction a = new CheckedRecursiveAction() {
722	>	protected void realCompute() {
723	>	assertNull(getPool());
724		}};
725	<	a.invoke();
725	>	assertNull(a.invoke());
726		}
727
728		/**
729		* inForkJoinPool of executing task returns true
730		*/
731		public void testInForkJoinPool() {
732	<	RecursiveAction a = new RecursiveAction() {
733	<	public void compute() {
734	<	threadAssertTrue(inForkJoinPool());
732	>	RecursiveAction a = new CheckedRecursiveAction() {
733	>	protected void realCompute() {
734	>	assertTrue(inForkJoinPool());
735		}};
736		testInvokeOnPool(mainPool(), a);
737		}
#	Line 602 | Line 740 | public class ForkJoinTaskTest extends JS
740		* inForkJoinPool of non-FJ task returns false
741		*/
742		public void testInForkJoinPool2() {
743	<	RecursiveAction a = new RecursiveAction() {
744	<	public void compute() {
745	<	threadAssertTrue(!inForkJoinPool());
743	>	RecursiveAction a = new CheckedRecursiveAction() {
744	>	protected void realCompute() {
745	>	assertFalse(inForkJoinPool());
746		}};
747	<	a.invoke();
747	>	assertNull(a.invoke());
748		}
749
750		/**
751		* setRawResult(null) succeeds
752		*/
753		public void testSetRawResult() {
754	<	RecursiveAction a = new RecursiveAction() {
755	<	public void compute() {
754	>	RecursiveAction a = new CheckedRecursiveAction() {
755	>	protected void realCompute() {
756		setRawResult(null);
757	+	assertNull(getRawResult());
758		}};
759	<	a.invoke();
759	>	assertNull(a.invoke());
760		}
761
762		/**
763		* invoke task throws exception after invoking completeExceptionally
764		*/
765		public void testCompleteExceptionally() {
766	<	RecursiveAction a = new RecursiveAction() {
767	<	public void compute() {
766	>	RecursiveAction a = new CheckedRecursiveAction() {
767	>	protected void realCompute() {
768	>	AsyncFib f = new AsyncFib(8);
769	>	f.completeExceptionally(new FJException());
770		try {
630	–	AsyncFib f = new AsyncFib(8);
631	–	f.completeExceptionally(new FJException());
771		f.invoke();
772		shouldThrow();
773		} catch (FJException success) {
774	+	checkCompletedAbnormally(f, success);
775	+	}
776	+	}};
777	+	testInvokeOnPool(mainPool(), a);
778	+	}
779	+
780	+	/**
781	+	* completeExceptionally(null) surprisingly has the same effect as
782	+	* completeExceptionally(new RuntimeException())
783	+	*/
784	+	public void testCompleteExceptionally_null() {
785	+	RecursiveAction a = new CheckedRecursiveAction() {
786	+	protected void realCompute() {
787	+	AsyncFib f = new AsyncFib(8);
788	+	f.completeExceptionally(null);
789	+	try {
790	+	f.invoke();
791	+	shouldThrow();
792	+	} catch (RuntimeException success) {
793	+	assertSame(success.getClass(), RuntimeException.class);
794	+	assertNull(success.getCause());
795	+	checkCompletedAbnormally(f, success);
796		}
797		}};
798		testInvokeOnPool(mainPool(), a);
#	Line 641 | Line 802 | public class ForkJoinTaskTest extends JS
802		* invokeAll(t1, t2) invokes all task arguments
803		*/
804		public void testInvokeAll2() {
805	<	RecursiveAction a = new RecursiveAction() {
806	<	public void compute() {
805	>	RecursiveAction a = new CheckedRecursiveAction() {
806	>	protected void realCompute() {
807		AsyncFib f = new AsyncFib(8);
808		AsyncFib g = new AsyncFib(9);
809		invokeAll(f, g);
810	<	threadAssertTrue(f.isDone());
811	<	threadAssertTrue(f.number == 21);
812	<	threadAssertTrue(g.isDone());
813	<	threadAssertTrue(g.number == 34);
810	>	assertEquals(21, f.number);
811	>	assertEquals(34, g.number);
812	>	checkCompletedNormally(f);
813	>	checkCompletedNormally(g);
814		}};
815		testInvokeOnPool(mainPool(), a);
816		}
#	Line 658 | Line 819 | public class ForkJoinTaskTest extends JS
819		* invokeAll(tasks) with 1 argument invokes task
820		*/
821		public void testInvokeAll1() {
822	<	RecursiveAction a = new RecursiveAction() {
823	<	public void compute() {
822	>	RecursiveAction a = new CheckedRecursiveAction() {
823	>	protected void realCompute() {
824		AsyncFib f = new AsyncFib(8);
825		invokeAll(f);
826	<	threadAssertTrue(f.isDone());
827	<	threadAssertTrue(f.number == 21);
826	>	checkCompletedNormally(f);
827	>	assertEquals(21, f.number);
828		}};
829		testInvokeOnPool(mainPool(), a);
830		}
#	Line 672 | Line 833 | public class ForkJoinTaskTest extends JS
833		* invokeAll(tasks) with > 2 argument invokes tasks
834		*/
835		public void testInvokeAll3() {
836	<	RecursiveAction a = new RecursiveAction() {
837	<	public void compute() {
836	>	RecursiveAction a = new CheckedRecursiveAction() {
837	>	protected void realCompute() {
838		AsyncFib f = new AsyncFib(8);
839		AsyncFib g = new AsyncFib(9);
840		AsyncFib h = new AsyncFib(7);
841		invokeAll(f, g, h);
842	<	threadAssertTrue(f.isDone());
843	<	threadAssertTrue(f.number == 21);
844	<	threadAssertTrue(g.isDone());
845	<	threadAssertTrue(g.number == 34);
846	<	threadAssertTrue(h.isDone());
847	<	threadAssertTrue(h.number == 13);
842	>	assertEquals(21, f.number);
843	>	assertEquals(34, g.number);
844	>	assertEquals(13, h.number);
845	>	checkCompletedNormally(f);
846	>	checkCompletedNormally(g);
847	>	checkCompletedNormally(h);
848		}};
849		testInvokeOnPool(mainPool(), a);
850		}
#	Line 692 | Line 853 | public class ForkJoinTaskTest extends JS
853		* invokeAll(collection) invokes all tasks in the collection
854		*/
855		public void testInvokeAllCollection() {
856	<	RecursiveAction a = new RecursiveAction() {
857	<	public void compute() {
856	>	RecursiveAction a = new CheckedRecursiveAction() {
857	>	protected void realCompute() {
858		AsyncFib f = new AsyncFib(8);
859		AsyncFib g = new AsyncFib(9);
860		AsyncFib h = new AsyncFib(7);
#	Line 702 | Line 863 | public class ForkJoinTaskTest extends JS
863		set.add(g);
864		set.add(h);
865		invokeAll(set);
866	<	threadAssertTrue(f.isDone());
867	<	threadAssertTrue(f.number == 21);
868	<	threadAssertTrue(g.isDone());
869	<	threadAssertTrue(g.number == 34);
870	<	threadAssertTrue(h.isDone());
871	<	threadAssertTrue(h.number == 13);
866	>	assertEquals(21, f.number);
867	>	assertEquals(34, g.number);
868	>	assertEquals(13, h.number);
869	>	checkCompletedNormally(f);
870	>	checkCompletedNormally(g);
871	>	checkCompletedNormally(h);
872		}};
873		testInvokeOnPool(mainPool(), a);
874		}
875
715	–
876		/**
877		* invokeAll(tasks) with any null task throws NPE
878		*/
879		public void testInvokeAllNPE() {
880	<	RecursiveAction a = new RecursiveAction() {
881	<	public void compute() {
880	>	RecursiveAction a = new CheckedRecursiveAction() {
881	>	protected void realCompute() {
882	>	AsyncFib f = new AsyncFib(8);
883	>	AsyncFib g = new AsyncFib(9);
884	>	AsyncFib h = null;
885		try {
723	–	AsyncFib f = new AsyncFib(8);
724	–	AsyncFib g = new AsyncFib(9);
725	–	AsyncFib h = null;
886		invokeAll(f, g, h);
887		shouldThrow();
888	<	} catch (NullPointerException success) {
729	<	}
888	>	} catch (NullPointerException success) {}
889		}};
890		testInvokeOnPool(mainPool(), a);
891		}
#	Line 735 | Line 894 | public class ForkJoinTaskTest extends JS
894		* invokeAll(t1, t2) throw exception if any task does
895		*/
896		public void testAbnormalInvokeAll2() {
897	<	RecursiveAction a = new RecursiveAction() {
898	<	public void compute() {
897	>	RecursiveAction a = new CheckedRecursiveAction() {
898	>	protected void realCompute() {
899	>	AsyncFib f = new AsyncFib(8);
900	>	FailingAsyncFib g = new FailingAsyncFib(9);
901	>	ForkJoinTask[] tasks = { f, g };
902	>	shuffle(tasks);
903		try {
904	<	AsyncFib f = new AsyncFib(8);
742	<	FailingAsyncFib g = new FailingAsyncFib(9);
743	<	invokeAll(f, g);
904	>	invokeAll(tasks);
905		shouldThrow();
906		} catch (FJException success) {
907	+	checkCompletedAbnormally(g, success);
908		}
909		}};
910		testInvokeOnPool(mainPool(), a);
#	Line 752 | Line 914 | public class ForkJoinTaskTest extends JS
914		* invokeAll(tasks) with 1 argument throws exception if task does
915		*/
916		public void testAbnormalInvokeAll1() {
917	<	RecursiveAction a = new RecursiveAction() {
918	<	public void compute() {
917	>	RecursiveAction a = new CheckedRecursiveAction() {
918	>	protected void realCompute() {
919	>	FailingAsyncFib g = new FailingAsyncFib(9);
920		try {
758	–	FailingAsyncFib g = new FailingAsyncFib(9);
921		invokeAll(g);
922		shouldThrow();
923		} catch (FJException success) {
924	+	checkCompletedAbnormally(g, success);
925		}
926		}};
927		testInvokeOnPool(mainPool(), a);
#	Line 768 | Line 931 | public class ForkJoinTaskTest extends JS
931		* invokeAll(tasks) with > 2 argument throws exception if any task does
932		*/
933		public void testAbnormalInvokeAll3() {
934	<	RecursiveAction a = new RecursiveAction() {
935	<	public void compute() {
934	>	RecursiveAction a = new CheckedRecursiveAction() {
935	>	protected void realCompute() {
936	>	AsyncFib f = new AsyncFib(8);
937	>	FailingAsyncFib g = new FailingAsyncFib(9);
938	>	AsyncFib h = new AsyncFib(7);
939	>	ForkJoinTask[] tasks = { f, g, h };
940	>	shuffle(tasks);
941		try {
942	<	AsyncFib f = new AsyncFib(8);
775	<	FailingAsyncFib g = new FailingAsyncFib(9);
776	<	AsyncFib h = new AsyncFib(7);
777	<	invokeAll(f, g, h);
942	>	invokeAll(tasks);
943		shouldThrow();
944		} catch (FJException success) {
945	+	checkCompletedAbnormally(g, success);
946		}
947		}};
948		testInvokeOnPool(mainPool(), a);
949		}
950
951		/**
952	<	* invokeAll(collection)  throws exception if any task does
952	>	* invokeAll(collection) throws exception if any task does
953		*/
954		public void testAbnormalInvokeAllCollection() {
955	<	RecursiveAction a = new RecursiveAction() {
956	<	public void compute() {
955	>	RecursiveAction a = new CheckedRecursiveAction() {
956	>	protected void realCompute() {
957	>	FailingAsyncFib f = new FailingAsyncFib(8);
958	>	AsyncFib g = new AsyncFib(9);
959	>	AsyncFib h = new AsyncFib(7);
960	>	ForkJoinTask[] tasks = { f, g, h };
961	>	shuffle(tasks);
962		try {
963	<	FailingAsyncFib f = new FailingAsyncFib(8);
793	<	AsyncFib g = new AsyncFib(9);
794	<	AsyncFib h = new AsyncFib(7);
795	<	HashSet set = new HashSet();
796	<	set.add(f);
797	<	set.add(g);
798	<	set.add(h);
799	<	invokeAll(set);
963	>	invokeAll(Arrays.asList(tasks));
964		shouldThrow();
965		} catch (FJException success) {
966	+	checkCompletedAbnormally(f, success);
967		}
968		}};
969		testInvokeOnPool(mainPool(), a);
#	Line 809 | Line 974 | public class ForkJoinTaskTest extends JS
974		* and suppresses execution
975		*/
976		public void testTryUnfork() {
977	<	RecursiveAction a = new RecursiveAction() {
978	<	public void compute() {
977	>	RecursiveAction a = new CheckedRecursiveAction() {
978	>	protected void realCompute() {
979		AsyncFib g = new AsyncFib(9);
980	<	g.fork();
980	>	assertSame(g, g.fork());
981		AsyncFib f = new AsyncFib(8);
982	<	f.fork();
983	<	threadAssertTrue(f.tryUnfork());
982	>	assertSame(f, f.fork());
983	>	assertTrue(f.tryUnfork());
984		helpQuiesce();
985	<	threadAssertFalse(f.isDone());
986	<	threadAssertTrue(g.isDone());
985	>	checkNotDone(f);
986	>	checkCompletedNormally(g);
987		}};
988		testInvokeOnPool(singletonPool(), a);
989		}
#	Line 828 | Line 993 | public class ForkJoinTaskTest extends JS
993		* there are more tasks than threads
994		*/
995		public void testGetSurplusQueuedTaskCount() {
996	<	RecursiveAction a = new RecursiveAction() {
997	<	public void compute() {
996	>	RecursiveAction a = new CheckedRecursiveAction() {
997	>	protected void realCompute() {
998		AsyncFib h = new AsyncFib(7);
999	<	h.fork();
999	>	assertSame(h, h.fork());
1000		AsyncFib g = new AsyncFib(9);
1001	<	g.fork();
1001	>	assertSame(g, g.fork());
1002		AsyncFib f = new AsyncFib(8);
1003	<	f.fork();
1004	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
1003	>	assertSame(f, f.fork());
1004	>	assertTrue(getSurplusQueuedTaskCount() > 0);
1005		helpQuiesce();
1006	+	assertEquals(0, getSurplusQueuedTaskCount());
1007	+	checkCompletedNormally(f);
1008	+	checkCompletedNormally(g);
1009	+	checkCompletedNormally(h);
1010		}};
1011		testInvokeOnPool(singletonPool(), a);
1012		}
#	Line 846 | Line 1015 | public class ForkJoinTaskTest extends JS
1015		* peekNextLocalTask returns most recent unexecuted task.
1016		*/
1017		public void testPeekNextLocalTask() {
1018	<	RecursiveAction a = new RecursiveAction() {
1019	<	public void compute() {
1018	>	RecursiveAction a = new CheckedRecursiveAction() {
1019	>	protected void realCompute() {
1020		AsyncFib g = new AsyncFib(9);
1021	<	g.fork();
1021	>	assertSame(g, g.fork());
1022		AsyncFib f = new AsyncFib(8);
1023	<	f.fork();
1024	<	threadAssertTrue(peekNextLocalTask() == f);
1025	<	f.join();
1026	<	threadAssertTrue(f.isDone());
1023	>	assertSame(f, f.fork());
1024	>	assertSame(f, peekNextLocalTask());
1025	>	assertNull(f.join());
1026	>	checkCompletedNormally(f);
1027		helpQuiesce();
1028	+	checkCompletedNormally(g);
1029		}};
1030		testInvokeOnPool(singletonPool(), a);
1031		}
1032
1033		/**
1034	<	* pollNextLocalTask returns most recent unexecuted task
1035	<	* without executing it
1034	>	* pollNextLocalTask returns most recent unexecuted task without
1035	>	* executing it
1036		*/
1037		public void testPollNextLocalTask() {
1038	<	RecursiveAction a = new RecursiveAction() {
1039	<	public void compute() {
1038	>	RecursiveAction a = new CheckedRecursiveAction() {
1039	>	protected void realCompute() {
1040		AsyncFib g = new AsyncFib(9);
1041	<	g.fork();
1041	>	assertSame(g, g.fork());
1042		AsyncFib f = new AsyncFib(8);
1043	<	f.fork();
1044	<	threadAssertTrue(pollNextLocalTask() == f);
1043	>	assertSame(f, f.fork());
1044	>	assertSame(f, pollNextLocalTask());
1045		helpQuiesce();
1046	<	threadAssertFalse(f.isDone());
1046	>	checkNotDone(f);
1047	>	assertEquals(34, g.number);
1048	>	checkCompletedNormally(g);
1049		}};
1050		testInvokeOnPool(singletonPool(), a);
1051		}
1052
1053		/**
1054	<	* pollTask returns an unexecuted task
883	<	* without executing it
1054	>	* pollTask returns an unexecuted task without executing it
1055		*/
1056		public void testPollTask() {
1057	<	RecursiveAction a = new RecursiveAction() {
1058	<	public void compute() {
1057	>	RecursiveAction a = new CheckedRecursiveAction() {
1058	>	protected void realCompute() {
1059		AsyncFib g = new AsyncFib(9);
1060	<	g.fork();
1060	>	assertSame(g, g.fork());
1061		AsyncFib f = new AsyncFib(8);
1062	<	f.fork();
1063	<	threadAssertTrue(pollTask() == f);
1062	>	assertSame(f, f.fork());
1063	>	assertSame(f, pollTask());
1064		helpQuiesce();
1065	<	threadAssertFalse(f.isDone());
1066	<	threadAssertTrue(g.isDone());
1065	>	checkNotDone(f);
1066	>	checkCompletedNormally(g);
1067		}};
1068		testInvokeOnPool(singletonPool(), a);
1069		}
#	Line 901 | Line 1072 | public class ForkJoinTaskTest extends JS
1072		* peekNextLocalTask returns least recent unexecuted task in async mode
1073		*/
1074		public void testPeekNextLocalTaskAsync() {
1075	<	RecursiveAction a = new RecursiveAction() {
1076	<	public void compute() {
1075	>	RecursiveAction a = new CheckedRecursiveAction() {
1076	>	protected void realCompute() {
1077		AsyncFib g = new AsyncFib(9);
1078	<	g.fork();
1078	>	assertSame(g, g.fork());
1079		AsyncFib f = new AsyncFib(8);
1080	<	f.fork();
1081	<	threadAssertTrue(peekNextLocalTask() == g);
1082	<	f.join();
1080	>	assertSame(f, f.fork());
1081	>	assertSame(g, peekNextLocalTask());
1082	>	assertNull(f.join());
1083		helpQuiesce();
1084	<	threadAssertTrue(f.isDone());
1084	>	checkCompletedNormally(f);
1085	>	assertEquals(34, g.number);
1086	>	checkCompletedNormally(g);
1087		}};
1088		testInvokeOnPool(asyncSingletonPool(), a);
1089		}
1090
1091		/**
1092	<	* pollNextLocalTask returns least recent unexecuted task
1093	<	* without executing it, in async mode
1092	>	* pollNextLocalTask returns least recent unexecuted task without
1093	>	* executing it, in async mode
1094		*/
1095		public void testPollNextLocalTaskAsync() {
1096	<	RecursiveAction a = new RecursiveAction() {
1097	<	public void compute() {
1096	>	RecursiveAction a = new CheckedRecursiveAction() {
1097	>	protected void realCompute() {
1098		AsyncFib g = new AsyncFib(9);
1099	<	g.fork();
1099	>	assertSame(g, g.fork());
1100		AsyncFib f = new AsyncFib(8);
1101	<	f.fork();
1102	<	threadAssertTrue(pollNextLocalTask() == g);
1101	>	assertSame(f, f.fork());
1102	>	assertSame(g, pollNextLocalTask());
1103		helpQuiesce();
1104	<	threadAssertTrue(f.isDone());
1105	<	threadAssertFalse(g.isDone());
1104	>	assertEquals(21, f.number);
1105	>	checkCompletedNormally(f);
1106	>	checkNotDone(g);
1107		}};
1108		testInvokeOnPool(asyncSingletonPool(), a);
1109		}
1110
1111		/**
1112	<	* pollTask returns an unexecuted task
1113	<	* without executing it, in async mode
1112	>	* pollTask returns an unexecuted task without executing it, in
1113	>	* async mode
1114		*/
1115		public void testPollTaskAsync() {
1116	<	RecursiveAction a = new RecursiveAction() {
1117	<	public void compute() {
1116	>	RecursiveAction a = new CheckedRecursiveAction() {
1117	>	protected void realCompute() {
1118		AsyncFib g = new AsyncFib(9);
1119	<	g.fork();
1119	>	assertSame(g, g.fork());
1120		AsyncFib f = new AsyncFib(8);
1121	<	f.fork();
1122	<	threadAssertTrue(pollTask() == g);
1121	>	assertSame(f, f.fork());
1122	>	assertSame(g, pollTask());
1123		helpQuiesce();
1124	<	threadAssertTrue(f.isDone());
1125	<	threadAssertFalse(g.isDone());
1124	>	assertEquals(21, f.number);
1125	>	checkCompletedNormally(f);
1126	>	checkNotDone(g);
1127		}};
1128		testInvokeOnPool(asyncSingletonPool(), a);
1129		}
1130	+
1131	+	// versions for singleton pools
1132	+
1133	+	/**
1134	+	* invoke returns when task completes normally.
1135	+	* isCompletedAbnormally and isCancelled return false for normally
1136	+	* completed tasks; getRawResult returns null.
1137	+	*/
1138	+	public void testInvokeSingleton() {
1139	+	RecursiveAction a = new CheckedRecursiveAction() {
1140	+	protected void realCompute() {
1141	+	AsyncFib f = new AsyncFib(8);
1142	+	assertNull(f.invoke());
1143	+	assertEquals(21, f.number);
1144	+	checkCompletedNormally(f);
1145	+	}};
1146	+	testInvokeOnPool(singletonPool(), a);
1147	+	}
1148	+
1149	+	/**
1150	+	* quietlyInvoke task returns when task completes normally.
1151	+	* isCompletedAbnormally and isCancelled return false for normally
1152	+	* completed tasks
1153	+	*/
1154	+	public void testQuietlyInvokeSingleton() {
1155	+	RecursiveAction a = new CheckedRecursiveAction() {
1156	+	protected void realCompute() {
1157	+	AsyncFib f = new AsyncFib(8);
1158	+	f.quietlyInvoke();
1159	+	assertEquals(21, f.number);
1160	+	checkCompletedNormally(f);
1161	+	}};
1162	+	testInvokeOnPool(singletonPool(), a);
1163	+	}
1164	+
1165	+	/**
1166	+	* join of a forked task returns when task completes
1167	+	*/
1168	+	public void testForkJoinSingleton() {
1169	+	RecursiveAction a = new CheckedRecursiveAction() {
1170	+	protected void realCompute() {
1171	+	AsyncFib f = new AsyncFib(8);
1172	+	assertSame(f, f.fork());
1173	+	assertNull(f.join());
1174	+	assertEquals(21, f.number);
1175	+	checkCompletedNormally(f);
1176	+	}};
1177	+	testInvokeOnPool(singletonPool(), a);
1178	+	}
1179	+
1180	+	/**
1181	+	* get of a forked task returns when task completes
1182	+	*/
1183	+	public void testForkGetSingleton() {
1184	+	RecursiveAction a = new CheckedRecursiveAction() {
1185	+	protected void realCompute() throws Exception {
1186	+	AsyncFib f = new AsyncFib(8);
1187	+	assertSame(f, f.fork());
1188	+	assertNull(f.get());
1189	+	assertEquals(21, f.number);
1190	+	checkCompletedNormally(f);
1191	+	}};
1192	+	testInvokeOnPool(singletonPool(), a);
1193	+	}
1194	+
1195	+	/**
1196	+	* timed get of a forked task returns when task completes
1197	+	*/
1198	+	public void testForkTimedGetSingleton() {
1199	+	RecursiveAction a = new CheckedRecursiveAction() {
1200	+	protected void realCompute() throws Exception {
1201	+	AsyncFib f = new AsyncFib(8);
1202	+	assertSame(f, f.fork());
1203	+	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
1204	+	assertEquals(21, f.number);
1205	+	checkCompletedNormally(f);
1206	+	}};
1207	+	testInvokeOnPool(singletonPool(), a);
1208	+	}
1209	+
1210	+	/**
1211	+	* timed get with null time unit throws NPE
1212	+	*/
1213	+	public void testForkTimedGetNPESingleton() {
1214	+	RecursiveAction a = new CheckedRecursiveAction() {
1215	+	protected void realCompute() throws Exception {
1216	+	AsyncFib f = new AsyncFib(8);
1217	+	assertSame(f, f.fork());
1218	+	try {
1219	+	f.get(randomTimeout(), null);
1220	+	shouldThrow();
1221	+	} catch (NullPointerException success) {}
1222	+	}};
1223	+	testInvokeOnPool(singletonPool(), a);
1224	+	}
1225	+
1226	+	/**
1227	+	* quietlyJoin of a forked task returns when task completes
1228	+	*/
1229	+	public void testForkQuietlyJoinSingleton() {
1230	+	RecursiveAction a = new CheckedRecursiveAction() {
1231	+	protected void realCompute() {
1232	+	AsyncFib f = new AsyncFib(8);
1233	+	assertSame(f, f.fork());
1234	+	f.quietlyJoin();
1235	+	assertEquals(21, f.number);
1236	+	checkCompletedNormally(f);
1237	+	}};
1238	+	testInvokeOnPool(singletonPool(), a);
1239	+	}
1240	+
1241	+	/**
1242	+	* helpQuiesce returns when tasks are complete.
1243	+	* getQueuedTaskCount returns 0 when quiescent
1244	+	*/
1245	+	public void testForkHelpQuiesceSingleton() {
1246	+	RecursiveAction a = new CheckedRecursiveAction() {
1247	+	protected void realCompute() {
1248	+	AsyncFib f = new AsyncFib(8);
1249	+	assertSame(f, f.fork());
1250	+	helpQuiesce();
1251	+	assertEquals(0, getQueuedTaskCount());
1252	+	assertEquals(21, f.number);
1253	+	checkCompletedNormally(f);
1254	+	}};
1255	+	testInvokeOnPool(singletonPool(), a);
1256	+	}
1257	+
1258	+	/**
1259	+	* invoke task throws exception when task completes abnormally
1260	+	*/
1261	+	public void testAbnormalInvokeSingleton() {
1262	+	RecursiveAction a = new CheckedRecursiveAction() {
1263	+	protected void realCompute() {
1264	+	FailingAsyncFib f = new FailingAsyncFib(8);
1265	+	try {
1266	+	f.invoke();
1267	+	shouldThrow();
1268	+	} catch (FJException success) {
1269	+	checkCompletedAbnormally(f, success);
1270	+	}
1271	+	}};
1272	+	testInvokeOnPool(singletonPool(), a);
1273	+	}
1274	+
1275	+	/**
1276	+	* quietlyInvoke task returns when task completes abnormally
1277	+	*/
1278	+	public void testAbnormalQuietlyInvokeSingleton() {
1279	+	RecursiveAction a = new CheckedRecursiveAction() {
1280	+	protected void realCompute() {
1281	+	FailingAsyncFib f = new FailingAsyncFib(8);
1282	+	f.quietlyInvoke();
1283	+	assertTrue(f.getException() instanceof FJException);
1284	+	checkCompletedAbnormally(f, f.getException());
1285	+	}};
1286	+	testInvokeOnPool(singletonPool(), a);
1287	+	}
1288	+
1289	+	/**
1290	+	* join of a forked task throws exception when task completes abnormally
1291	+	*/
1292	+	public void testAbnormalForkJoinSingleton() {
1293	+	RecursiveAction a = new CheckedRecursiveAction() {
1294	+	protected void realCompute() {
1295	+	FailingAsyncFib f = new FailingAsyncFib(8);
1296	+	assertSame(f, f.fork());
1297	+	try {
1298	+	f.join();
1299	+	shouldThrow();
1300	+	} catch (FJException success) {
1301	+	checkCompletedAbnormally(f, success);
1302	+	}
1303	+	}};
1304	+	testInvokeOnPool(singletonPool(), a);
1305	+	}
1306	+
1307	+	/**
1308	+	* get of a forked task throws exception when task completes abnormally
1309	+	*/
1310	+	public void testAbnormalForkGetSingleton() {
1311	+	RecursiveAction a = new CheckedRecursiveAction() {
1312	+	protected void realCompute() throws Exception {
1313	+	FailingAsyncFib f = new FailingAsyncFib(8);
1314	+	assertSame(f, f.fork());
1315	+	try {
1316	+	f.get();
1317	+	shouldThrow();
1318	+	} catch (ExecutionException success) {
1319	+	Throwable cause = success.getCause();
1320	+	assertTrue(cause instanceof FJException);
1321	+	checkCompletedAbnormally(f, cause);
1322	+	}
1323	+	}};
1324	+	testInvokeOnPool(singletonPool(), a);
1325	+	}
1326	+
1327	+	/**
1328	+	* timed get of a forked task throws exception when task completes abnormally
1329	+	*/
1330	+	public void testAbnormalForkTimedGetSingleton() {
1331	+	RecursiveAction a = new CheckedRecursiveAction() {
1332	+	protected void realCompute() throws Exception {
1333	+	FailingAsyncFib f = new FailingAsyncFib(8);
1334	+	assertSame(f, f.fork());
1335	+	try {
1336	+	f.get(LONG_DELAY_MS, MILLISECONDS);
1337	+	shouldThrow();
1338	+	} catch (ExecutionException success) {
1339	+	Throwable cause = success.getCause();
1340	+	assertTrue(cause instanceof FJException);
1341	+	checkCompletedAbnormally(f, cause);
1342	+	}
1343	+	}};
1344	+	testInvokeOnPool(singletonPool(), a);
1345	+	}
1346	+
1347	+	/**
1348	+	* quietlyJoin of a forked task returns when task completes abnormally
1349	+	*/
1350	+	public void testAbnormalForkQuietlyJoinSingleton() {
1351	+	RecursiveAction a = new CheckedRecursiveAction() {
1352	+	protected void realCompute() {
1353	+	FailingAsyncFib f = new FailingAsyncFib(8);
1354	+	assertSame(f, f.fork());
1355	+	f.quietlyJoin();
1356	+	assertTrue(f.getException() instanceof FJException);
1357	+	checkCompletedAbnormally(f, f.getException());
1358	+	}};
1359	+	testInvokeOnPool(singletonPool(), a);
1360	+	}
1361	+
1362	+	/**
1363	+	* invoke task throws exception when task cancelled
1364	+	*/
1365	+	public void testCancelledInvokeSingleton() {
1366	+	RecursiveAction a = new CheckedRecursiveAction() {
1367	+	protected void realCompute() {
1368	+	AsyncFib f = new AsyncFib(8);
1369	+	assertTrue(f.cancel(true));
1370	+	try {
1371	+	f.invoke();
1372	+	shouldThrow();
1373	+	} catch (CancellationException success) {
1374	+	checkCancelled(f);
1375	+	}
1376	+	}};
1377	+	testInvokeOnPool(singletonPool(), a);
1378	+	}
1379	+
1380	+	/**
1381	+	* join of a forked task throws exception when task cancelled
1382	+	*/
1383	+	public void testCancelledForkJoinSingleton() {
1384	+	RecursiveAction a = new CheckedRecursiveAction() {
1385	+	protected void realCompute() {
1386	+	AsyncFib f = new AsyncFib(8);
1387	+	assertTrue(f.cancel(true));
1388	+	assertSame(f, f.fork());
1389	+	try {
1390	+	f.join();
1391	+	shouldThrow();
1392	+	} catch (CancellationException success) {
1393	+	checkCancelled(f);
1394	+	}
1395	+	}};
1396	+	testInvokeOnPool(singletonPool(), a);
1397	+	}
1398	+
1399	+	/**
1400	+	* get of a forked task throws exception when task cancelled
1401	+	*/
1402	+	public void testCancelledForkGetSingleton() {
1403	+	RecursiveAction a = new CheckedRecursiveAction() {
1404	+	protected void realCompute() throws Exception {
1405	+	AsyncFib f = new AsyncFib(8);
1406	+	assertTrue(f.cancel(true));
1407	+	assertSame(f, f.fork());
1408	+	try {
1409	+	f.get();
1410	+	shouldThrow();
1411	+	} catch (CancellationException success) {
1412	+	checkCancelled(f);
1413	+	}
1414	+	}};
1415	+	testInvokeOnPool(singletonPool(), a);
1416	+	}
1417	+
1418	+	/**
1419	+	* timed get of a forked task throws exception when task cancelled
1420	+	*/
1421	+	public void testCancelledForkTimedGetSingleton() throws Exception {
1422	+	RecursiveAction a = new CheckedRecursiveAction() {
1423	+	protected void realCompute() throws Exception {
1424	+	AsyncFib f = new AsyncFib(8);
1425	+	assertTrue(f.cancel(true));
1426	+	assertSame(f, f.fork());
1427	+	try {
1428	+	f.get(LONG_DELAY_MS, MILLISECONDS);
1429	+	shouldThrow();
1430	+	} catch (CancellationException success) {
1431	+	checkCancelled(f);
1432	+	}
1433	+	}};
1434	+	testInvokeOnPool(singletonPool(), a);
1435	+	}
1436	+
1437	+	/**
1438	+	* quietlyJoin of a forked task returns when task cancelled
1439	+	*/
1440	+	public void testCancelledForkQuietlyJoinSingleton() {
1441	+	RecursiveAction a = new CheckedRecursiveAction() {
1442	+	protected void realCompute() {
1443	+	AsyncFib f = new AsyncFib(8);
1444	+	assertTrue(f.cancel(true));
1445	+	assertSame(f, f.fork());
1446	+	f.quietlyJoin();
1447	+	checkCancelled(f);
1448	+	}};
1449	+	testInvokeOnPool(singletonPool(), a);
1450	+	}
1451	+
1452	+	/**
1453	+	* invoke task throws exception after invoking completeExceptionally
1454	+	*/
1455	+	public void testCompleteExceptionallySingleton() {
1456	+	RecursiveAction a = new CheckedRecursiveAction() {
1457	+	protected void realCompute() {
1458	+	AsyncFib f = new AsyncFib(8);
1459	+	f.completeExceptionally(new FJException());
1460	+	try {
1461	+	f.invoke();
1462	+	shouldThrow();
1463	+	} catch (FJException success) {
1464	+	checkCompletedAbnormally(f, success);
1465	+	}
1466	+	}};
1467	+	testInvokeOnPool(singletonPool(), a);
1468	+	}
1469	+
1470	+	/**
1471	+	* invokeAll(t1, t2) invokes all task arguments
1472	+	*/
1473	+	public void testInvokeAll2Singleton() {
1474	+	RecursiveAction a = new CheckedRecursiveAction() {
1475	+	protected void realCompute() {
1476	+	AsyncFib f = new AsyncFib(8);
1477	+	AsyncFib g = new AsyncFib(9);
1478	+	invokeAll(f, g);
1479	+	assertEquals(21, f.number);
1480	+	assertEquals(34, g.number);
1481	+	checkCompletedNormally(f);
1482	+	checkCompletedNormally(g);
1483	+	}};
1484	+	testInvokeOnPool(singletonPool(), a);
1485	+	}
1486	+
1487	+	/**
1488	+	* invokeAll(tasks) with 1 argument invokes task
1489	+	*/
1490	+	public void testInvokeAll1Singleton() {
1491	+	RecursiveAction a = new CheckedRecursiveAction() {
1492	+	protected void realCompute() {
1493	+	AsyncFib f = new AsyncFib(8);
1494	+	invokeAll(f);
1495	+	checkCompletedNormally(f);
1496	+	assertEquals(21, f.number);
1497	+	}};
1498	+	testInvokeOnPool(singletonPool(), a);
1499	+	}
1500	+
1501	+	/**
1502	+	* invokeAll(tasks) with > 2 argument invokes tasks
1503	+	*/
1504	+	public void testInvokeAll3Singleton() {
1505	+	RecursiveAction a = new CheckedRecursiveAction() {
1506	+	protected void realCompute() {
1507	+	AsyncFib f = new AsyncFib(8);
1508	+	AsyncFib g = new AsyncFib(9);
1509	+	AsyncFib h = new AsyncFib(7);
1510	+	invokeAll(f, g, h);
1511	+	assertEquals(21, f.number);
1512	+	assertEquals(34, g.number);
1513	+	assertEquals(13, h.number);
1514	+	checkCompletedNormally(f);
1515	+	checkCompletedNormally(g);
1516	+	checkCompletedNormally(h);
1517	+	}};
1518	+	testInvokeOnPool(singletonPool(), a);
1519	+	}
1520	+
1521	+	/**
1522	+	* invokeAll(collection) invokes all tasks in the collection
1523	+	*/
1524	+	public void testInvokeAllCollectionSingleton() {
1525	+	RecursiveAction a = new CheckedRecursiveAction() {
1526	+	protected void realCompute() {
1527	+	AsyncFib f = new AsyncFib(8);
1528	+	AsyncFib g = new AsyncFib(9);
1529	+	AsyncFib h = new AsyncFib(7);
1530	+	HashSet set = new HashSet();
1531	+	set.add(f);
1532	+	set.add(g);
1533	+	set.add(h);
1534	+	invokeAll(set);
1535	+	assertEquals(21, f.number);
1536	+	assertEquals(34, g.number);
1537	+	assertEquals(13, h.number);
1538	+	checkCompletedNormally(f);
1539	+	checkCompletedNormally(g);
1540	+	checkCompletedNormally(h);
1541	+	}};
1542	+	testInvokeOnPool(singletonPool(), a);
1543	+	}
1544	+
1545	+	/**
1546	+	* invokeAll(tasks) with any null task throws NPE
1547	+	*/
1548	+	public void testInvokeAllNPESingleton() {
1549	+	RecursiveAction a = new CheckedRecursiveAction() {
1550	+	protected void realCompute() {
1551	+	AsyncFib f = new AsyncFib(8);
1552	+	AsyncFib g = new AsyncFib(9);
1553	+	AsyncFib h = null;
1554	+	try {
1555	+	invokeAll(f, g, h);
1556	+	shouldThrow();
1557	+	} catch (NullPointerException success) {}
1558	+	}};
1559	+	testInvokeOnPool(singletonPool(), a);
1560	+	}
1561	+
1562	+	/**
1563	+	* invokeAll(t1, t2) throw exception if any task does
1564	+	*/
1565	+	public void testAbnormalInvokeAll2Singleton() {
1566	+	RecursiveAction a = new CheckedRecursiveAction() {
1567	+	protected void realCompute() {
1568	+	AsyncFib f = new AsyncFib(8);
1569	+	FailingAsyncFib g = new FailingAsyncFib(9);
1570	+	ForkJoinTask[] tasks = { f, g };
1571	+	shuffle(tasks);
1572	+	try {
1573	+	invokeAll(tasks);
1574	+	shouldThrow();
1575	+	} catch (FJException success) {
1576	+	checkCompletedAbnormally(g, success);
1577	+	}
1578	+	}};
1579	+	testInvokeOnPool(singletonPool(), a);
1580	+	}
1581	+
1582	+	/**
1583	+	* invokeAll(tasks) with 1 argument throws exception if task does
1584	+	*/
1585	+	public void testAbnormalInvokeAll1Singleton() {
1586	+	RecursiveAction a = new CheckedRecursiveAction() {
1587	+	protected void realCompute() {
1588	+	FailingAsyncFib g = new FailingAsyncFib(9);
1589	+	try {
1590	+	invokeAll(g);
1591	+	shouldThrow();
1592	+	} catch (FJException success) {
1593	+	checkCompletedAbnormally(g, success);
1594	+	}
1595	+	}};
1596	+	testInvokeOnPool(singletonPool(), a);
1597	+	}
1598	+
1599	+	/**
1600	+	* invokeAll(tasks) with > 2 argument throws exception if any task does
1601	+	*/
1602	+	public void testAbnormalInvokeAll3Singleton() {
1603	+	RecursiveAction a = new CheckedRecursiveAction() {
1604	+	protected void realCompute() {
1605	+	AsyncFib f = new AsyncFib(8);
1606	+	FailingAsyncFib g = new FailingAsyncFib(9);
1607	+	AsyncFib h = new AsyncFib(7);
1608	+	ForkJoinTask[] tasks = { f, g, h };
1609	+	shuffle(tasks);
1610	+	try {
1611	+	invokeAll(tasks);
1612	+	shouldThrow();
1613	+	} catch (FJException success) {
1614	+	checkCompletedAbnormally(g, success);
1615	+	}
1616	+	}};
1617	+	testInvokeOnPool(singletonPool(), a);
1618	+	}
1619	+
1620	+	/**
1621	+	* invokeAll(collection) throws exception if any task does
1622	+	*/
1623	+	public void testAbnormalInvokeAllCollectionSingleton() {
1624	+	RecursiveAction a = new CheckedRecursiveAction() {
1625	+	protected void realCompute() {
1626	+	FailingAsyncFib f = new FailingAsyncFib(8);
1627	+	AsyncFib g = new AsyncFib(9);
1628	+	AsyncFib h = new AsyncFib(7);
1629	+	ForkJoinTask[] tasks = { f, g, h };
1630	+	shuffle(tasks);
1631	+	try {
1632	+	invokeAll(Arrays.asList(tasks));
1633	+	shouldThrow();
1634	+	} catch (FJException success) {
1635	+	checkCompletedAbnormally(f, success);
1636	+	}
1637	+	}};
1638	+	testInvokeOnPool(singletonPool(), a);
1639	+	}
1640	+
1641	+	/**
1642	+	* ForkJoinTask.quietlyComplete returns when task completes
1643	+	* normally without setting a value. The most recent value
1644	+	* established by setRawResult(V) (or null by default) is returned
1645	+	* from invoke.
1646	+	*/
1647	+	public void testQuietlyComplete() {
1648	+	RecursiveAction a = new CheckedRecursiveAction() {
1649	+	protected void realCompute() {
1650	+	AsyncFib f = new AsyncFib(8);
1651	+	f.quietlyComplete();
1652	+	assertEquals(8, f.number);
1653	+	checkCompletedNormally(f);
1654	+	}};
1655	+	testInvokeOnPool(mainPool(), a);
1656	+	}
1657	+
1658	+	/**
1659	+	* adapt(runnable).toString() contains toString of wrapped task
1660	+	*/
1661	+	public void testAdapt_Runnable_toString() {
1662	+	if (testImplementationDetails) {
1663	+	Runnable r = () -> {};
1664	+	ForkJoinTask<?> task = ForkJoinTask.adapt(r);
1665	+	assertEquals(
1666	+	identityString(task) + "[Wrapped task = " + r.toString() + "]",
1667	+	task.toString());
1668	+	}
1669	+	}
1670	+
1671	+	/**
1672	+	* adapt(runnable, x).toString() contains toString of wrapped task
1673	+	*/
1674	+	public void testAdapt_Runnable_withResult_toString() {
1675	+	if (testImplementationDetails) {
1676	+	Runnable r = () -> {};
1677	+	ForkJoinTask<String> task = ForkJoinTask.adapt(r, "");
1678	+	assertEquals(
1679	+	identityString(task) + "[Wrapped task = " + r.toString() + "]",
1680	+	task.toString());
1681	+	}
1682	+	}
1683	+
1684	+	/**
1685	+	* adapt(callable).toString() contains toString of wrapped task
1686	+	*/
1687	+	public void testAdapt_Callable_toString() {
1688	+	if (testImplementationDetails) {
1689	+	Callable<String> c = () -> "";
1690	+	ForkJoinTask<String> task = ForkJoinTask.adapt(c);
1691	+	assertEquals(
1692	+	identityString(task) + "[Wrapped task = " + c.toString() + "]",
1693	+	task.toString());
1694	+	}
1695	+	}
1696	+
1697	+	// adaptInterruptible deferred to its own independent change
1698	+	// https://bugs.openjdk.java.net/browse/JDK-8246587
1699	+
1700	+	//     /**
1701	+	//      * adaptInterruptible(callable).toString() contains toString of wrapped task
1702	+	//      */
1703	+	//     public void testAdaptInterruptible_Callable_toString() {
1704	+	//         if (testImplementationDetails) {
1705	+	//             Callable<String> c = () -> "";
1706	+	//             ForkJoinTask<String> task = ForkJoinTask.adaptInterruptible(c);
1707	+	//             assertEquals(
1708	+	//                 identityString(task) + "[Wrapped task = " + c.toString() + "]",
1709	+	//                 task.toString());
1710	+	//         }
1711	+	//     }
1712		}

Diff Legend

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