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

Diff Legend

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