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

Diff Legend

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