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.5 by jsr166, Sat Nov 21 02:07:26 2009 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 junit.framework.*;
7	<	import java.util.concurrent.*;
8	<	import java.util.concurrent.atomic.*;
9	<	import java.util.*;
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;
15	>	import java.util.concurrent.RecursiveAction;
16	>	import java.util.concurrent.TimeoutException;
17	>	import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
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	<	/**
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(mainPoolSize);
38	>	}
39	>
40	>	private static ForkJoinPool singletonPool() {
41	>	return new ForkJoinPool(1);
42	>	}
43	>
44	>	private static ForkJoinPool asyncSingletonPool() {
45	>	return new ForkJoinPool(1,
46	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
47	>	null, true);
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	>	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	>	/*
199		* Testing coverage notes:
200		*
201		* To test extension methods and overrides, most tests use
#	Line 25 | Line 203 | public class ForkJoinTaskTest extends JS
203		* differently than supplied Recursive forms.
204		*/
205
206	<	static final ForkJoinPool mainPool = new ForkJoinPool();
29	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
30	<	static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
31	<	static {
32	<	asyncSingletonPool.setAsyncMode(true);
33	<	}
34	<
35	<	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 80 | 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 101 | Line 280 | public class ForkJoinTaskTest extends JS
280		}
281
282		public final void completeExceptionally(Throwable ex) {
283	<	BinaryAsyncAction a = this;
105	<	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 148 | Line 326 | public class ForkJoinTaskTest extends JS
326
327		}
328
329	<	static final class AsyncFib  extends BinaryAsyncAction {
329	>	static final class AsyncFib extends BinaryAsyncAction {
330		int number;
331		public AsyncFib(int n) {
332		this.number = n;
#	Line 157 | 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);
166	<	r.fork();
167	<	}
168	<	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 176 | Line 351 | public class ForkJoinTaskTest extends JS
351		}
352		}
353
354	<
180	<	static final class FailingAsyncFib  extends BinaryAsyncAction {
354	>	static final class FailingAsyncFib extends BinaryAsyncAction {
355		int number;
356		public FailingAsyncFib(int n) {
357		this.number = n;
#	Line 186 | 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);
195	<	r.fork();
196	<	}
197	<	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 208 | 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;
212	<	*
382	>	* completed tasks; getRawResult returns null.
383		*/
384		public void testInvoke() {
385	<	RecursiveAction a = new RecursiveAction() {
386	<	public void compute() {
387	<	AsyncFib f = new AsyncFib(8);
388	<	f.invoke();
389	<	threadAssertTrue(f.number == 21);
390	<	threadAssertTrue(f.isDone());
391	<	threadAssertFalse(f.isCancelled());
392	<	threadAssertFalse(f.isCompletedAbnormally());
223	<	threadAssertTrue(f.getRawResult() == null);
224	<	}
225	<	};
226	<	mainPool.invoke(a);
385	>	RecursiveAction a = new CheckedRecursiveAction() {
386	>	protected void realCompute() {
387	>	AsyncFib f = new AsyncFib(8);
388	>	assertNull(f.invoke());
389	>	assertEquals(21, f.number);
390	>	checkCompletedNormally(f);
391	>	}};
392	>	testInvokeOnPool(mainPool(), a);
393		}
394
395		/**
#	Line 232 | Line 398 | public class ForkJoinTaskTest extends JS
398		* completed tasks
399		*/
400		public void testQuietlyInvoke() {
401	<	RecursiveAction a = new RecursiveAction() {
402	<	public void compute() {
403	<	AsyncFib f = new AsyncFib(8);
404	<	f.quietlyInvoke();
405	<	threadAssertTrue(f.number == 21);
406	<	threadAssertTrue(f.isDone());
407	<	threadAssertFalse(f.isCancelled());
408	<	threadAssertFalse(f.isCompletedAbnormally());
243	<	threadAssertTrue(f.getRawResult() == null);
244	<	}
245	<	};
246	<	mainPool.invoke(a);
401	>	RecursiveAction a = new CheckedRecursiveAction() {
402	>	protected void realCompute() {
403	>	AsyncFib f = new AsyncFib(8);
404	>	f.quietlyInvoke();
405	>	assertEquals(21, f.number);
406	>	checkCompletedNormally(f);
407	>	}};
408	>	testInvokeOnPool(mainPool(), a);
409		}
410
411		/**
412		* join of a forked task returns when task completes
413		*/
414		public void testForkJoin() {
415	<	RecursiveAction a = new RecursiveAction() {
416	<	public void compute() {
417	<	AsyncFib f = new AsyncFib(8);
418	<	f.fork();
419	<	f.join();
420	<	threadAssertTrue(f.number == 21);
421	<	threadAssertTrue(f.isDone());
422	<	threadAssertTrue(f.getRawResult() == null);
423	<	}
262	<	};
263	<	mainPool.invoke(a);
415	>	RecursiveAction a = new CheckedRecursiveAction() {
416	>	protected void realCompute() {
417	>	AsyncFib f = new AsyncFib(8);
418	>	assertSame(f, f.fork());
419	>	assertNull(f.join());
420	>	assertEquals(21, f.number);
421	>	checkCompletedNormally(f);
422	>	}};
423	>	testInvokeOnPool(mainPool(), a);
424		}
425
426		/**
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);
437	<	threadAssertTrue(f.isDone());
438	<	} catch (Exception ex) {
279	<	unexpectedException(ex);
280	<	}
281	<	}
282	<	};
283	<	mainPool.invoke(a);
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		}
440
441		/**
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(5L, TimeUnit.SECONDS);
451	<	threadAssertTrue(f.number == 21);
452	<	threadAssertTrue(f.isDone());
453	<	} catch (Exception ex) {
299	<	unexpectedException(ex);
300	<	}
301	<	}
302	<	};
303	<	mainPool.invoke(a);
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		}
455
456		/**
457		* timed get with null time unit throws NPE
458		*/
459		public void testForkTimedGetNPE() {
460	<	RecursiveAction a = new RecursiveAction() {
461	<	public void compute() {
462	<	try {
463	<	AsyncFib f = new AsyncFib(8);
464	<	f.fork();
465	<	f.get(5L, null);
466	<	shouldThrow();
467	<	} catch (NullPointerException success) {
468	<	} catch (Exception ex) {
469	<	unexpectedException(ex);
320	<	}
321	<	}
322	<	};
323	<	mainPool.invoke(a);
324	<	}
325	<
326	<	/**
327	<	* helpJoin of a forked task returns when task completes
328	<	*/
329	<	public void testForkHelpJoin() {
330	<	RecursiveAction a = new RecursiveAction() {
331	<	public void compute() {
332	<	AsyncFib f = new AsyncFib(8);
333	<	f.fork();
334	<	f.helpJoin();
335	<	threadAssertTrue(f.number == 21);
336	<	threadAssertTrue(f.isDone());
337	<	}
338	<	};
339	<	mainPool.invoke(a);
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	>	f.get(randomTimeout(), null);
466	>	shouldThrow();
467	>	} catch (NullPointerException success) {}
468	>	}};
469	>	testInvokeOnPool(mainPool(), a);
470		}
471
472		/**
473		* quietlyJoin of a forked task returns when task completes
474		*/
475		public void testForkQuietlyJoin() {
476	<	RecursiveAction a = new RecursiveAction() {
477	<	public void compute() {
478	<	AsyncFib f = new AsyncFib(8);
479	<	f.fork();
480	<	f.quietlyJoin();
481	<	threadAssertTrue(f.number == 21);
482	<	threadAssertTrue(f.isDone());
483	<	}
484	<	};
355	<	mainPool.invoke(a);
356	<	}
357	<
358	<
359	<	/**
360	<	* quietlyHelpJoin of a forked task returns when task completes
361	<	*/
362	<	public void testForkQuietlyHelpJoin() {
363	<	RecursiveAction a = new RecursiveAction() {
364	<	public void compute() {
365	<	AsyncFib f = new AsyncFib(8);
366	<	f.fork();
367	<	f.quietlyHelpJoin();
368	<	threadAssertTrue(f.number == 21);
369	<	threadAssertTrue(f.isDone());
370	<	}
371	<	};
372	<	mainPool.invoke(a);
476	>	RecursiveAction a = new CheckedRecursiveAction() {
477	>	protected void realCompute() {
478	>	AsyncFib f = new AsyncFib(8);
479	>	assertSame(f, f.fork());
480	>	f.quietlyJoin();
481	>	assertEquals(21, f.number);
482	>	checkCompletedNormally(f);
483	>	}};
484	>	testInvokeOnPool(mainPool(), a);
485		}
486
375	–
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() {
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);
500	<	}
501	<	};
391	<	mainPool.invoke(a);
492	>	RecursiveAction a = new CheckedRecursiveAction() {
493	>	protected void realCompute() {
494	>	AsyncFib f = new AsyncFib(8);
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
394	–
504		/**
505		* invoke task throws exception when task completes abnormally
506		*/
507		public void testAbnormalInvoke() {
508	<	RecursiveAction a = new RecursiveAction() {
509	<	public void compute() {
510	<	try {
511	<	FailingAsyncFib f = new FailingAsyncFib(8);
512	<	f.invoke();
513	<	shouldThrow();
514	<	} catch (FJException success) {
515	<	}
508	>	RecursiveAction a = new CheckedRecursiveAction() {
509	>	protected void realCompute() {
510	>	FailingAsyncFib f = new FailingAsyncFib(8);
511	>	try {
512	>	f.invoke();
513	>	shouldThrow();
514	>	} catch (FJException success) {
515	>	checkCompletedAbnormally(f, success);
516		}
517	<	};
518	<	mainPool.invoke(a);
517	>	}};
518	>	testInvokeOnPool(mainPool(), a);
519		}
520
521		/**
522		* quietlyInvoke task returns when task completes abnormally
523		*/
524		public void testAbnormalQuietlyInvoke() {
525	<	RecursiveAction a = new RecursiveAction() {
526	<	public void compute() {
527	<	FailingAsyncFib f = new FailingAsyncFib(8);
528	<	f.quietlyInvoke();
529	<	threadAssertTrue(f.isDone());
530	<	}
531	<	};
532	<	mainPool.invoke(a);
525	>	RecursiveAction a = new CheckedRecursiveAction() {
526	>	protected void realCompute() {
527	>	FailingAsyncFib f = new FailingAsyncFib(8);
528	>	f.quietlyInvoke();
529	>	assertTrue(f.getException() instanceof FJException);
530	>	checkCompletedAbnormally(f, f.getException());
531	>	}};
532	>	testInvokeOnPool(mainPool(), a);
533		}
534
535		/**
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() {
541	<	try {
542	<	FailingAsyncFib f = new FailingAsyncFib(8);
543	<	f.fork();
544	<	f.join();
545	<	shouldThrow();
546	<	} catch (FJException success) {
547	<	}
539	>	RecursiveAction a = new CheckedRecursiveAction() {
540	>	protected void realCompute() {
541	>	FailingAsyncFib f = new FailingAsyncFib(8);
542	>	assertSame(f, f.fork());
543	>	try {
544	>	f.join();
545	>	shouldThrow();
546	>	} catch (FJException success) {
547	>	checkCompletedAbnormally(f, success);
548		}
549	<	};
550	<	mainPool.invoke(a);
549	>	}};
550	>	testInvokeOnPool(mainPool(), a);
551		}
552
553		/**
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() {
559	<	try {
560	<	FailingAsyncFib f = new FailingAsyncFib(8);
561	<	f.fork();
562	<	f.get();
563	<	shouldThrow();
564	<	} catch (ExecutionException success) {
565	<	} catch (Exception ex) {
566	<	unexpectedException(ex);
567	<	}
557	>	RecursiveAction a = new CheckedRecursiveAction() {
558	>	protected void realCompute() throws Exception {
559	>	FailingAsyncFib f = new FailingAsyncFib(8);
560	>	assertSame(f, f.fork());
561	>	try {
562	>	f.get();
563	>	shouldThrow();
564	>	} catch (ExecutionException success) {
565	>	Throwable cause = success.getCause();
566	>	assertTrue(cause instanceof FJException);
567	>	checkCompletedAbnormally(f, cause);
568		}
569	<	};
570	<	mainPool.invoke(a);
569	>	}};
570	>	testInvokeOnPool(mainPool(), a);
571		}
572
573		/**
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() {
579	<	try {
580	<	FailingAsyncFib f = new FailingAsyncFib(8);
581	<	f.fork();
582	<	f.get(5L, TimeUnit.SECONDS);
583	<	shouldThrow();
584	<	} catch (ExecutionException success) {
585	<	} catch (Exception ex) {
586	<	unexpectedException(ex);
587	<	}
479	<	}
480	<	};
481	<	mainPool.invoke(a);
482	<	}
483	<
484	<	/**
485	<	* join of a forked task throws exception when task completes abnormally
486	<	*/
487	<	public void testAbnormalForkHelpJoin() {
488	<	RecursiveAction a = new RecursiveAction() {
489	<	public void compute() {
490	<	try {
491	<	FailingAsyncFib f = new FailingAsyncFib(8);
492	<	f.fork();
493	<	f.helpJoin();
494	<	shouldThrow();
495	<	} catch (FJException success) {
496	<	}
497	<	}
498	<	};
499	<	mainPool.invoke(a);
500	<	}
501	<
502	<	/**
503	<	* quietlyHelpJoin of a forked task returns when task completes abnormally.
504	<	* getException of failed task returns its exception.
505	<	* isCompletedAbnormally of a failed task returns true.
506	<	* isCancelled of a failed uncancelled task returns false
507	<	*/
508	<	public void testAbnormalForkQuietlyHelpJoin() {
509	<	RecursiveAction a = new RecursiveAction() {
510	<	public void compute() {
511	<	FailingAsyncFib f = new FailingAsyncFib(8);
512	<	f.fork();
513	<	f.quietlyHelpJoin();
514	<	threadAssertTrue(f.isDone());
515	<	threadAssertTrue(f.isCompletedAbnormally());
516	<	threadAssertFalse(f.isCancelled());
517	<	threadAssertTrue(f.getException() instanceof FJException);
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	>	f.get(LONG_DELAY_MS, MILLISECONDS);
583	>	shouldThrow();
584	>	} catch (ExecutionException success) {
585	>	Throwable cause = success.getCause();
586	>	assertTrue(cause instanceof FJException);
587	>	checkCompletedAbnormally(f, cause);
588		}
589	<	};
590	<	mainPool.invoke(a);
589	>	}};
590	>	testInvokeOnPool(mainPool(), a);
591		}
592
593		/**
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() {
599	<	FailingAsyncFib f = new FailingAsyncFib(8);
600	<	f.fork();
601	<	f.quietlyJoin();
602	<	threadAssertTrue(f.isDone());
603	<	threadAssertTrue(f.isCompletedAbnormally());
604	<	threadAssertTrue(f.getException() instanceof FJException);
605	<	}
536	<	};
537	<	mainPool.invoke(a);
597	>	RecursiveAction a = new CheckedRecursiveAction() {
598	>	protected void realCompute() {
599	>	FailingAsyncFib f = new FailingAsyncFib(8);
600	>	assertSame(f, f.fork());
601	>	f.quietlyJoin();
602	>	assertTrue(f.getException() instanceof FJException);
603	>	checkCompletedAbnormally(f, f.getException());
604	>	}};
605	>	testInvokeOnPool(mainPool(), a);
606		}
607
608		/**
609		* invoke task throws exception when task cancelled
610		*/
611		public void testCancelledInvoke() {
612	<	RecursiveAction a = new RecursiveAction() {
613	<	public void compute() {
614	<	try {
615	<	AsyncFib f = new AsyncFib(8);
616	<	f.cancel(true);
617	<	f.invoke();
618	<	shouldThrow();
619	<	} catch (CancellationException success) {
620	<	}
612	>	RecursiveAction a = new CheckedRecursiveAction() {
613	>	protected void realCompute() {
614	>	AsyncFib f = new AsyncFib(8);
615	>	assertTrue(f.cancel(true));
616	>	try {
617	>	f.invoke();
618	>	shouldThrow();
619	>	} catch (CancellationException success) {
620	>	checkCancelled(f);
621		}
622	<	};
623	<	mainPool.invoke(a);
622	>	}};
623	>	testInvokeOnPool(mainPool(), a);
624		}
625
626		/**
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() {
632	<	try {
633	<	AsyncFib f = new AsyncFib(8);
634	<	f.cancel(true);
635	<	f.fork();
636	<	f.join();
637	<	shouldThrow();
638	<	} catch (CancellationException success) {
639	<	}
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 {
636	>	f.join();
637	>	shouldThrow();
638	>	} catch (CancellationException success) {
639	>	checkCancelled(f);
640		}
641	<	};
642	<	mainPool.invoke(a);
641	>	}};
642	>	testInvokeOnPool(mainPool(), a);
643		}
644
645		/**
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() {
651	<	try {
652	<	AsyncFib f = new AsyncFib(8);
653	<	f.cancel(true);
654	<	f.fork();
655	<	f.get();
656	<	shouldThrow();
657	<	} catch (CancellationException success) {
658	<	} catch (Exception ex) {
591	<	unexpectedException(ex);
592	<	}
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 {
655	>	f.get();
656	>	shouldThrow();
657	>	} catch (CancellationException success) {
658	>	checkCancelled(f);
659		}
660	<	};
661	<	mainPool.invoke(a);
660	>	}};
661	>	testInvokeOnPool(mainPool(), a);
662		}
663
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() {
670	<	try {
671	<	AsyncFib f = new AsyncFib(8);
672	<	f.cancel(true);
673	<	f.fork();
674	<	f.get(5L, TimeUnit.SECONDS);
675	<	shouldThrow();
676	<	} catch (CancellationException success) {
677	<	} catch (Exception ex) {
612	<	unexpectedException(ex);
613	<	}
614	<	}
615	<	};
616	<	mainPool.invoke(a);
617	<	}
618	<
619	<	/**
620	<	* join of a forked task throws exception when task cancelled
621	<	*/
622	<	public void testCancelledForkHelpJoin() {
623	<	RecursiveAction a = new RecursiveAction() {
624	<	public void compute() {
625	<	try {
626	<	AsyncFib f = new AsyncFib(8);
627	<	f.cancel(true);
628	<	f.fork();
629	<	f.helpJoin();
630	<	shouldThrow();
631	<	} catch (CancellationException success) {
632	<	}
633	<	}
634	<	};
635	<	mainPool.invoke(a);
636	<	}
637	<
638	<	/**
639	<	* quietlyHelpJoin of a forked task returns when task cancelled.
640	<	* getException of cancelled task returns its exception.
641	<	* isCompletedAbnormally of a cancelled task returns true.
642	<	* isCancelled of a cancelled task returns true
643	<	*/
644	<	public void testCancelledForkQuietlyHelpJoin() {
645	<	RecursiveAction a = new RecursiveAction() {
646	<	public void compute() {
647	<	AsyncFib f = new AsyncFib(8);
648	<	f.cancel(true);
649	<	f.fork();
650	<	f.quietlyHelpJoin();
651	<	threadAssertTrue(f.isDone());
652	<	threadAssertTrue(f.isCompletedAbnormally());
653	<	threadAssertTrue(f.isCancelled());
654	<	threadAssertTrue(f.getException() instanceof CancellationException);
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	>	f.get(LONG_DELAY_MS, MILLISECONDS);
675	>	shouldThrow();
676	>	} catch (CancellationException success) {
677	>	checkCancelled(f);
678		}
679	<	};
680	<	mainPool.invoke(a);
679	>	}};
680	>	testInvokeOnPool(mainPool(), a);
681		}
682
683		/**
684		* quietlyJoin of a forked task returns when task cancelled
685		*/
686		public void testCancelledForkQuietlyJoin() {
687	<	RecursiveAction a = new RecursiveAction() {
688	<	public void compute() {
689	<	AsyncFib f = new AsyncFib(8);
690	<	f.cancel(true);
691	<	f.fork();
692	<	f.quietlyJoin();
693	<	threadAssertTrue(f.isDone());
694	<	threadAssertTrue(f.isCompletedAbnormally());
695	<	threadAssertTrue(f.getException() instanceof CancellationException);
673	<	}
674	<	};
675	<	mainPool.invoke(a);
687	>	RecursiveAction a = new CheckedRecursiveAction() {
688	>	protected void realCompute() {
689	>	AsyncFib f = new AsyncFib(8);
690	>	assertTrue(f.cancel(true));
691	>	assertSame(f, f.fork());
692	>	f.quietlyJoin();
693	>	checkCancelled(f);
694	>	}};
695	>	testInvokeOnPool(mainPool(), a);
696		}
697
698		/**
699		* getPool of executing task returns its pool
700		*/
701		public void testGetPool() {
702	<	RecursiveAction a = new RecursiveAction() {
703	<	public void compute() {
704	<	threadAssertTrue(getPool() == mainPool);
705	<	}
706	<	};
707	<	mainPool.invoke(a);
702	>	final ForkJoinPool mainPool = mainPool();
703	>	RecursiveAction a = new CheckedRecursiveAction() {
704	>	protected void realCompute() {
705	>	assertSame(mainPool, getPool());
706	>	}};
707	>	testInvokeOnPool(mainPool, a);
708		}
709
710		/**
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);
717	<	}
718	<	};
699	<	a.invoke();
714	>	RecursiveAction a = new CheckedRecursiveAction() {
715	>	protected void realCompute() {
716	>	assertNull(getPool());
717	>	}};
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());
728	<	}
729	<	};
711	<	mainPool.invoke(a);
725	>	RecursiveAction a = new CheckedRecursiveAction() {
726	>	protected void realCompute() {
727	>	assertTrue(inForkJoinPool());
728	>	}};
729	>	testInvokeOnPool(mainPool(), a);
730		}
731
732		/**
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());
739	<	}
740	<	};
723	<	a.invoke();
736	>	RecursiveAction a = new CheckedRecursiveAction() {
737	>	protected void realCompute() {
738	>	assertFalse(inForkJoinPool());
739	>	}};
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() {
749	<	setRawResult(null);
750	<	}
751	<	};
752	<	a.invoke();
747	>	RecursiveAction a = new CheckedRecursiveAction() {
748	>	protected void realCompute() {
749	>	setRawResult(null);
750	>	assertNull(getRawResult());
751	>	}};
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() {
761	<	try {
762	<	AsyncFib f = new AsyncFib(8);
763	<	f.completeExceptionally(new FJException());
764	<	f.invoke();
765	<	shouldThrow();
766	<	} catch (FJException success) {
767	<	}
759	>	RecursiveAction a = new CheckedRecursiveAction() {
760	>	protected void realCompute() {
761	>	AsyncFib f = new AsyncFib(8);
762	>	f.completeExceptionally(new FJException());
763	>	try {
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	<	mainPool.invoke(a);
790	>	}};
791	>	testInvokeOnPool(mainPool(), a);
792		}
793
794		/**
795		* invokeAll(t1, t2) invokes all task arguments
796		*/
797		public void testInvokeAll2() {
798	<	RecursiveAction a = new RecursiveAction() {
799	<	public void compute() {
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);
807	<	}
808	<	};
771	<	mainPool.invoke(a);
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	>	assertEquals(21, f.number);
804	>	assertEquals(34, g.number);
805	>	checkCompletedNormally(f);
806	>	checkCompletedNormally(g);
807	>	}};
808	>	testInvokeOnPool(mainPool(), a);
809		}
810
811		/**
812		* invokeAll(tasks) with 1 argument invokes task
813		*/
814		public void testInvokeAll1() {
815	<	RecursiveAction a = new RecursiveAction() {
816	<	public void compute() {
817	<	AsyncFib f = new AsyncFib(8);
818	<	invokeAll(f);
819	<	threadAssertTrue(f.isDone());
820	<	threadAssertTrue(f.number == 21);
821	<	}
822	<	};
786	<	mainPool.invoke(a);
815	>	RecursiveAction a = new CheckedRecursiveAction() {
816	>	protected void realCompute() {
817	>	AsyncFib f = new AsyncFib(8);
818	>	invokeAll(f);
819	>	checkCompletedNormally(f);
820	>	assertEquals(21, f.number);
821	>	}};
822	>	testInvokeOnPool(mainPool(), a);
823		}
824
825		/**
826		* invokeAll(tasks) with > 2 argument invokes tasks
827		*/
828		public void testInvokeAll3() {
829	<	RecursiveAction a = new RecursiveAction() {
830	<	public void compute() {
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);
841	<	}
842	<	};
807	<	mainPool.invoke(a);
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	>	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		}
844
845		/**
846		* invokeAll(collection) invokes all tasks in the collection
847		*/
848		public void testInvokeAllCollection() {
849	<	RecursiveAction a = new RecursiveAction() {
850	<	public void compute() {
851	<	AsyncFib f = new AsyncFib(8);
852	<	AsyncFib g = new AsyncFib(9);
853	<	AsyncFib h = new AsyncFib(7);
854	<	HashSet set = new HashSet();
855	<	set.add(f);
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);
865	<	}
866	<	};
832	<	mainPool.invoke(a);
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);
854	>	HashSet set = new HashSet();
855	>	set.add(f);
856	>	set.add(g);
857	>	set.add(h);
858	>	invokeAll(set);
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
835	–
869		/**
870		* invokeAll(tasks) with any null task throws NPE
871		*/
872		public void testInvokeAllNPE() {
873	<	RecursiveAction a = new RecursiveAction() {
874	<	public void compute() {
875	<	try {
876	<	AsyncFib f = new AsyncFib(8);
877	<	AsyncFib g = new AsyncFib(9);
878	<	AsyncFib h = null;
879	<	invokeAll(f, g, h);
880	<	shouldThrow();
881	<	} catch (NullPointerException success) {
882	<	}
883	<	}
851	<	};
852	<	mainPool.invoke(a);
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 {
879	>	invokeAll(f, g, h);
880	>	shouldThrow();
881	>	} catch (NullPointerException success) {}
882	>	}};
883	>	testInvokeOnPool(mainPool(), a);
884		}
885
886		/**
887		* invokeAll(t1, t2) throw exception if any task does
888		*/
889		public void testAbnormalInvokeAll2() {
890	<	RecursiveAction a = new RecursiveAction() {
891	<	public void compute() {
892	<	try {
893	<	AsyncFib f = new AsyncFib(8);
894	<	FailingAsyncFib g = new FailingAsyncFib(9);
895	<	invokeAll(f, g);
896	<	shouldThrow();
897	<	} catch (FJException success) {
898	<	}
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	>	invokeAll(tasks);
898	>	shouldThrow();
899	>	} catch (FJException success) {
900	>	checkCompletedAbnormally(g, success);
901		}
902	<	};
903	<	mainPool.invoke(a);
902	>	}};
903	>	testInvokeOnPool(mainPool(), a);
904		}
905
906		/**
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() {
912	<	try {
913	<	FailingAsyncFib g = new FailingAsyncFib(9);
914	<	invokeAll(g);
915	<	shouldThrow();
916	<	} catch (FJException success) {
917	<	}
910	>	RecursiveAction a = new CheckedRecursiveAction() {
911	>	protected void realCompute() {
912	>	FailingAsyncFib g = new FailingAsyncFib(9);
913	>	try {
914	>	invokeAll(g);
915	>	shouldThrow();
916	>	} catch (FJException success) {
917	>	checkCompletedAbnormally(g, success);
918		}
919	<	};
920	<	mainPool.invoke(a);
919	>	}};
920	>	testInvokeOnPool(mainPool(), a);
921		}
922
923		/**
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() {
929	<	try {
930	<	AsyncFib f = new AsyncFib(8);
931	<	FailingAsyncFib g = new FailingAsyncFib(9);
932	<	AsyncFib h = new AsyncFib(7);
933	<	invokeAll(f, g, h);
934	<	shouldThrow();
935	<	} catch (FJException success) {
936	<	}
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	>	invokeAll(tasks);
936	>	shouldThrow();
937	>	} catch (FJException success) {
938	>	checkCompletedAbnormally(g, success);
939		}
940	<	};
941	<	mainPool.invoke(a);
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() {
950	<	try {
951	<	FailingAsyncFib f = new FailingAsyncFib(8);
952	<	AsyncFib g = new AsyncFib(9);
953	<	AsyncFib h = new AsyncFib(7);
954	<	HashSet set = new HashSet();
955	<	set.add(f);
956	<	set.add(g);
957	<	set.add(h);
958	<	invokeAll(set);
959	<	shouldThrow();
925	<	} catch (FJException success) {
926	<	}
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	>	invokeAll(Arrays.asList(tasks));
957	>	shouldThrow();
958	>	} catch (FJException success) {
959	>	checkCompletedAbnormally(f, success);
960		}
961	<	};
962	<	mainPool.invoke(a);
961	>	}};
962	>	testInvokeOnPool(mainPool(), a);
963		}
964
965		/**
#	Line 934 | 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() {
972	<	AsyncFib g = new AsyncFib(9);
973	<	g.fork();
974	<	AsyncFib f = new AsyncFib(8);
975	<	f.fork();
976	<	threadAssertTrue(f.tryUnfork());
977	<	helpQuiesce();
978	<	threadAssertFalse(f.isDone());
979	<	threadAssertTrue(g.isDone());
980	<	}
981	<	};
949	<	singletonPool.invoke(a);
970	>	RecursiveAction a = new CheckedRecursiveAction() {
971	>	protected void realCompute() {
972	>	AsyncFib g = new AsyncFib(9);
973	>	assertSame(g, g.fork());
974	>	AsyncFib f = new AsyncFib(8);
975	>	assertSame(f, f.fork());
976	>	assertTrue(f.tryUnfork());
977	>	helpQuiesce();
978	>	checkNotDone(f);
979	>	checkCompletedNormally(g);
980	>	}};
981	>	testInvokeOnPool(singletonPool(), a);
982		}
983
984		/**
#	Line 954 | 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() {
991	<	AsyncFib h = new AsyncFib(7);
992	<	h.fork();
993	<	AsyncFib g = new AsyncFib(9);
994	<	g.fork();
995	<	AsyncFib f = new AsyncFib(8);
996	<	f.fork();
997	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
998	<	helpQuiesce();
999	<	}
1000	<	};
1001	<	singletonPool.invoke(a);
989	>	RecursiveAction a = new CheckedRecursiveAction() {
990	>	protected void realCompute() {
991	>	AsyncFib h = new AsyncFib(7);
992	>	assertSame(h, h.fork());
993	>	AsyncFib g = new AsyncFib(9);
994	>	assertSame(g, g.fork());
995	>	AsyncFib f = new AsyncFib(8);
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		}
1006
1007		/**
1008		* peekNextLocalTask returns most recent unexecuted task.
1009		*/
1010		public void testPeekNextLocalTask() {
1011	<	RecursiveAction a = new RecursiveAction() {
1012	<	public void compute() {
1013	<	AsyncFib g = new AsyncFib(9);
1014	<	g.fork();
1015	<	AsyncFib f = new AsyncFib(8);
1016	<	f.fork();
1017	<	threadAssertTrue(peekNextLocalTask() == f);
1018	<	f.join();
1019	<	threadAssertTrue(f.isDone());
1020	<	helpQuiesce();
1021	<	}
1022	<	};
1023	<	singletonPool.invoke(a);
1011	>	RecursiveAction a = new CheckedRecursiveAction() {
1012	>	protected void realCompute() {
1013	>	AsyncFib g = new AsyncFib(9);
1014	>	assertSame(g, g.fork());
1015	>	AsyncFib f = new AsyncFib(8);
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() {
1033	<	AsyncFib g = new AsyncFib(9);
1034	<	g.fork();
1035	<	AsyncFib f = new AsyncFib(8);
1036	<	f.fork();
1037	<	threadAssertTrue(pollNextLocalTask() == f);
1038	<	helpQuiesce();
1039	<	threadAssertFalse(f.isDone());
1040	<	}
1041	<	};
1042	<	singletonPool.invoke(a);
1031	>	RecursiveAction a = new CheckedRecursiveAction() {
1032	>	protected void realCompute() {
1033	>	AsyncFib g = new AsyncFib(9);
1034	>	assertSame(g, g.fork());
1035	>	AsyncFib f = new AsyncFib(8);
1036	>	assertSame(f, f.fork());
1037	>	assertSame(f, pollNextLocalTask());
1038	>	helpQuiesce();
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
1012	<	* 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() {
1052	<	AsyncFib g = new AsyncFib(9);
1053	<	g.fork();
1054	<	AsyncFib f = new AsyncFib(8);
1055	<	f.fork();
1056	<	threadAssertTrue(pollTask() == f);
1057	<	helpQuiesce();
1058	<	threadAssertFalse(f.isDone());
1059	<	threadAssertTrue(g.isDone());
1060	<	}
1061	<	};
1027	<	singletonPool.invoke(a);
1050	>	RecursiveAction a = new CheckedRecursiveAction() {
1051	>	protected void realCompute() {
1052	>	AsyncFib g = new AsyncFib(9);
1053	>	assertSame(g, g.fork());
1054	>	AsyncFib f = new AsyncFib(8);
1055	>	assertSame(f, f.fork());
1056	>	assertSame(f, pollTask());
1057	>	helpQuiesce();
1058	>	checkNotDone(f);
1059	>	checkCompletedNormally(g);
1060	>	}};
1061	>	testInvokeOnPool(singletonPool(), a);
1062		}
1063
1064		/**
1065		* peekNextLocalTask returns least recent unexecuted task in async mode
1066		*/
1067		public void testPeekNextLocalTaskAsync() {
1068	<	RecursiveAction a = new RecursiveAction() {
1069	<	public void compute() {
1070	<	AsyncFib g = new AsyncFib(9);
1071	<	g.fork();
1072	<	AsyncFib f = new AsyncFib(8);
1073	<	f.fork();
1074	<	threadAssertTrue(peekNextLocalTask() == g);
1068	>	RecursiveAction a = new CheckedRecursiveAction() {
1069	>	protected void realCompute() {
1070	>	AsyncFib g = new AsyncFib(9);
1071	>	assertSame(g, g.fork());
1072	>	AsyncFib f = new AsyncFib(8);
1073	>	assertSame(f, f.fork());
1074	>	assertSame(g, peekNextLocalTask());
1075	>	assertNull(f.join());
1076	>	helpQuiesce();
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 without
1086	>	* executing it, in async mode
1087	>	*/
1088	>	public void testPollNextLocalTaskAsync() {
1089	>	RecursiveAction a = new CheckedRecursiveAction() {
1090	>	protected void realCompute() {
1091	>	AsyncFib g = new AsyncFib(9);
1092	>	assertSame(g, g.fork());
1093	>	AsyncFib f = new AsyncFib(8);
1094	>	assertSame(f, f.fork());
1095	>	assertSame(g, pollNextLocalTask());
1096	>	helpQuiesce();
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 without executing it, in
1106	>	* async mode
1107	>	*/
1108	>	public void testPollTaskAsync() {
1109	>	RecursiveAction a = new CheckedRecursiveAction() {
1110	>	protected void realCompute() {
1111	>	AsyncFib g = new AsyncFib(9);
1112	>	assertSame(g, g.fork());
1113	>	AsyncFib f = new AsyncFib(8);
1114	>	assertSame(f, f.fork());
1115	>	assertSame(g, pollTask());
1116	>	helpQuiesce();
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	<	helpQuiesce();
1293	<	threadAssertTrue(f.isDone());
1292	>	shouldThrow();
1293	>	} catch (FJException success) {
1294	>	checkCompletedAbnormally(f, success);
1295		}
1296	<	};
1297	<	asyncSingletonPool.invoke(a);
1296	>	}};
1297	>	testInvokeOnPool(singletonPool(), a);
1298		}
1299
1300		/**
1301	<	* pollNextLocalTask returns least recent unexecuted task
1051	<	* without executing it, in async mode
1301	>	* get of a forked task throws exception when task completes abnormally
1302		*/
1303	<	public void testPollNextLocalTaskAsync() {
1304	<	RecursiveAction a = new RecursiveAction() {
1305	<	public void compute() {
1306	<	AsyncFib g = new AsyncFib(9);
1307	<	g.fork();
1308	<	AsyncFib f = new AsyncFib(8);
1309	<	f.fork();
1310	<	threadAssertTrue(pollNextLocalTask() == g);
1311	<	helpQuiesce();
1312	<	threadAssertTrue(f.isDone());
1313	<	threadAssertFalse(g.isDone());
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	<	asyncSingletonPool.invoke(a);
1316	>	}};
1317	>	testInvokeOnPool(singletonPool(), a);
1318		}
1319
1320		/**
1321	<	* pollTask returns an unexecuted task
1071	<	* without executing it, in async mode
1321	>	* timed get of a forked task throws exception when task completes abnormally
1322		*/
1323	<	public void testPollTaskAsync() {
1324	<	RecursiveAction a = new RecursiveAction() {
1325	<	public void compute() {
1326	<	AsyncFib g = new AsyncFib(9);
1327	<	g.fork();
1328	<	AsyncFib f = new AsyncFib(8);
1329	<	f.fork();
1330	<	threadAssertTrue(pollTask() == g);
1331	<	helpQuiesce();
1332	<	threadAssertTrue(f.isDone());
1333	<	threadAssertFalse(g.isDone());
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	<	asyncSingletonPool.invoke(a);
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