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.39 by jsr166, Wed Dec 31 17:00:58 2014 UTC

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

Diff Legend

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