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.16 by jsr166, Mon Sep 13 23:23:44 2010 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.concurrent.ExecutionException;
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;
10	–	import java.util.concurrent.ForkJoinWorkerThread;
11		import java.util.concurrent.RecursiveAction;
12	<	import java.util.concurrent.TimeUnit;
12	>	import java.util.concurrent.TimeoutException;
13		import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
14	<	import java.util.HashSet;
14	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
15	>	import static java.util.concurrent.TimeUnit.SECONDS;
16		import junit.framework.*;
17
18		public class ForkJoinTaskTest extends JSR166TestCase {
#	Line 24 | Line 25 | public class ForkJoinTaskTest extends JS
25		return new TestSuite(ForkJoinTaskTest.class);
26		}
27
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();
33	>	return new ForkJoinPool(mainPoolSize);
34		}
35
36		private static ForkJoinPool singletonPool() {
#	Line 40 | Line 45 | public class ForkJoinTaskTest extends JS
45
46		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
47		try {
48	<	assertTrue(pool.invoke(a) == null);
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		*
#	Line 54 | Line 203 | public class ForkJoinTaskTest extends JS
203		* differently than supplied Recursive forms.
204		*/
205
206	<	static final class FJException extends RuntimeException {
206	>	public static final class FJException extends RuntimeException {
207		FJException() { super(); }
208		}
209
210	<	static abstract class BinaryAsyncAction extends ForkJoinTask<Void> {
210	>	abstract static class BinaryAsyncAction extends ForkJoinTask<Void> {
211		private volatile int controlState;
212
213		static final AtomicIntegerFieldUpdater<BinaryAsyncAction> controlStateUpdater =
#	Line 198 | Line 347 | public class ForkJoinTaskTest extends JS
347		}
348		}
349
201	–
350		static final class FailingAsyncFib extends BinaryAsyncAction {
351		int number;
352		public FailingAsyncFib(int n) {
#	Line 230 | 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;
381	>	* completed tasks; getRawResult returns null.
382		*/
383		public void testInvoke() {
384	<	RecursiveAction a = new RecursiveAction() {
385	<	public void compute() {
384	>	RecursiveAction a = new CheckedRecursiveAction() {
385	>	protected void realCompute() {
386		AsyncFib f = new AsyncFib(8);
387	<	threadAssertNull(f.invoke());
388	<	threadAssertTrue(f.number == 21);
389	<	threadAssertTrue(f.isDone());
242	<	threadAssertFalse(f.isCancelled());
243	<	threadAssertFalse(f.isCompletedAbnormally());
244	<	threadAssertTrue(f.getRawResult() == null);
387	>	assertNull(f.invoke());
388	>	assertEquals(21, f.number);
389	>	checkCompletedNormally(f);
390		}};
391		testInvokeOnPool(mainPool(), a);
392		}
#	Line 252 | Line 397 | public class ForkJoinTaskTest extends JS
397		* completed tasks
398		*/
399		public void testQuietlyInvoke() {
400	<	RecursiveAction a = new RecursiveAction() {
401	<	public void compute() {
400	>	RecursiveAction a = new CheckedRecursiveAction() {
401	>	protected void realCompute() {
402		AsyncFib f = new AsyncFib(8);
403		f.quietlyInvoke();
404	<	threadAssertTrue(f.number == 21);
405	<	threadAssertTrue(f.isDone());
261	<	threadAssertFalse(f.isCancelled());
262	<	threadAssertFalse(f.isCompletedAbnormally());
263	<	threadAssertTrue(f.getRawResult() == null);
404	>	assertEquals(21, f.number);
405	>	checkCompletedNormally(f);
406		}};
407		testInvokeOnPool(mainPool(), a);
408		}
#	Line 269 | Line 411 | public class ForkJoinTaskTest extends JS
411		* join of a forked task returns when task completes
412		*/
413		public void testForkJoin() {
414	<	RecursiveAction a = new RecursiveAction() {
415	<	public void compute() {
414	>	RecursiveAction a = new CheckedRecursiveAction() {
415	>	protected void realCompute() {
416		AsyncFib f = new AsyncFib(8);
417	<	threadAssertSame(f, f.fork());
418	<	threadAssertNull(f.join());
419	<	threadAssertTrue(f.number == 21);
420	<	threadAssertTrue(f.isDone());
279	<	threadAssertTrue(f.getRawResult() == null);
417	>	assertSame(f, f.fork());
418	>	assertNull(f.join());
419	>	assertEquals(21, f.number);
420	>	checkCompletedNormally(f);
421		}};
422		testInvokeOnPool(mainPool(), a);
423		}
#	Line 285 | Line 426 | public class ForkJoinTaskTest extends JS
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	<	threadAssertSame(f, f.fork());
434	<	threadAssertNull(f.get());
435	<	threadAssertTrue(f.number == 21);
295	<	threadAssertTrue(f.isDone());
296	<	} catch (Exception ex) {
297	<	unexpectedException(ex);
298	<	}
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		}
#	Line 304 | Line 441 | public class ForkJoinTaskTest extends JS
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	<	threadAssertSame(f, f.fork());
449	<	threadAssertNull(f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
450	<	threadAssertTrue(f.number == 21);
314	<	threadAssertTrue(f.isDone());
315	<	} catch (Exception ex) {
316	<	unexpectedException(ex);
317	<	}
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		}
#	Line 323 | Line 456 | public class ForkJoinTaskTest extends JS
456		* timed get with null time unit throws NPE
457		*/
458		public void testForkTimedGetNPE() {
459	<	RecursiveAction a = new RecursiveAction() {
460	<	public void compute() {
459	>	RecursiveAction a = new CheckedRecursiveAction() {
460	>	protected void realCompute() throws Exception {
461	>	AsyncFib f = new AsyncFib(8);
462	>	assertSame(f, f.fork());
463		try {
329	–	AsyncFib f = new AsyncFib(8);
330	–	threadAssertSame(f, f.fork());
464		f.get(5L, null);
465		shouldThrow();
466	<	} catch (NullPointerException success) {
334	<	} catch (Exception ex) {
335	<	unexpectedException(ex);
336	<	}
466	>	} catch (NullPointerException success) {}
467		}};
468		testInvokeOnPool(mainPool(), a);
469		}
#	Line 342 | Line 472 | public class ForkJoinTaskTest extends JS
472		* quietlyJoin of a forked task returns when task completes
473		*/
474		public void testForkQuietlyJoin() {
475	<	RecursiveAction a = new RecursiveAction() {
476	<	public void compute() {
475	>	RecursiveAction a = new CheckedRecursiveAction() {
476	>	protected void realCompute() {
477		AsyncFib f = new AsyncFib(8);
478	<	threadAssertSame(f, f.fork());
478	>	assertSame(f, f.fork());
479		f.quietlyJoin();
480	<	threadAssertTrue(f.number == 21);
481	<	threadAssertTrue(f.isDone());
480	>	assertEquals(21, f.number);
481	>	checkCompletedNormally(f);
482		}};
483		testInvokeOnPool(mainPool(), a);
484		}
485
356	–
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() {
491	>	RecursiveAction a = new CheckedRecursiveAction() {
492	>	protected void realCompute() {
493		AsyncFib f = new AsyncFib(8);
494	<	threadAssertSame(f, f.fork());
495	<	f.helpQuiesce();
496	<	threadAssertTrue(f.number == 21);
497	<	threadAssertTrue(f.isDone());
498	<	threadAssertTrue(getQueuedTaskCount() == 0);
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
374	–
503		/**
504		* invoke task throws exception when task completes abnormally
505		*/
506		public void testAbnormalInvoke() {
507	<	RecursiveAction a = new RecursiveAction() {
508	<	public void compute() {
507	>	RecursiveAction a = new CheckedRecursiveAction() {
508	>	protected void realCompute() {
509	>	FailingAsyncFib f = new FailingAsyncFib(8);
510		try {
382	–	FailingAsyncFib f = new FailingAsyncFib(8);
511		f.invoke();
512		shouldThrow();
513		} catch (FJException success) {
514	+	checkCompletedAbnormally(f, success);
515		}
516		}};
517		testInvokeOnPool(mainPool(), a);
#	Line 392 | Line 521 | public class ForkJoinTaskTest extends JS
521		* quietlyInvoke task returns when task completes abnormally
522		*/
523		public void testAbnormalQuietlyInvoke() {
524	<	RecursiveAction a = new RecursiveAction() {
525	<	public void compute() {
524	>	RecursiveAction a = new CheckedRecursiveAction() {
525	>	protected void realCompute() {
526		FailingAsyncFib f = new FailingAsyncFib(8);
527		f.quietlyInvoke();
528	<	threadAssertTrue(f.isDone());
528	>	assertTrue(f.getException() instanceof FJException);
529	>	checkCompletedAbnormally(f, f.getException());
530		}};
531		testInvokeOnPool(mainPool(), a);
532		}
#	Line 405 | Line 535 | public class ForkJoinTaskTest extends JS
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() {
538	>	RecursiveAction a = new CheckedRecursiveAction() {
539	>	protected void realCompute() {
540	>	FailingAsyncFib f = new FailingAsyncFib(8);
541	>	assertSame(f, f.fork());
542		try {
411	–	FailingAsyncFib f = new FailingAsyncFib(8);
412	–	threadAssertSame(f, f.fork());
543		f.join();
544		shouldThrow();
545		} catch (FJException success) {
546	+	checkCompletedAbnormally(f, success);
547		}
548		}};
549		testInvokeOnPool(mainPool(), a);
#	Line 422 | Line 553 | public class ForkJoinTaskTest extends JS
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() {
556	>	RecursiveAction a = new CheckedRecursiveAction() {
557	>	protected void realCompute() throws Exception {
558	>	FailingAsyncFib f = new FailingAsyncFib(8);
559	>	assertSame(f, f.fork());
560		try {
428	–	FailingAsyncFib f = new FailingAsyncFib(8);
429	–	threadAssertSame(f, f.fork());
561		f.get();
562		shouldThrow();
563		} catch (ExecutionException success) {
564	<	} catch (Exception ex) {
565	<	unexpectedException(ex);
564	>	Throwable cause = success.getCause();
565	>	assertTrue(cause instanceof FJException);
566	>	checkCompletedAbnormally(f, cause);
567		}
568		}};
569		testInvokeOnPool(mainPool(), a);
#	Line 441 | Line 573 | public class ForkJoinTaskTest extends JS
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() {
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	<	FailingAsyncFib f = new FailingAsyncFib(8);
448	<	threadAssertSame(f, f.fork());
449	<	f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
581	>	f.get(LONG_DELAY_MS, MILLISECONDS);
582		shouldThrow();
583		} catch (ExecutionException success) {
584	<	} catch (Exception ex) {
585	<	unexpectedException(ex);
584	>	Throwable cause = success.getCause();
585	>	assertTrue(cause instanceof FJException);
586	>	checkCompletedAbnormally(f, cause);
587		}
588		}};
589		testInvokeOnPool(mainPool(), a);
#	Line 460 | Line 593 | public class ForkJoinTaskTest extends JS
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() {
596	>	RecursiveAction a = new CheckedRecursiveAction() {
597	>	protected void realCompute() {
598		FailingAsyncFib f = new FailingAsyncFib(8);
599	<	threadAssertSame(f, f.fork());
599	>	assertSame(f, f.fork());
600		f.quietlyJoin();
601	<	threadAssertTrue(f.isDone());
602	<	threadAssertTrue(f.isCompletedAbnormally());
470	<	threadAssertTrue(f.getException() instanceof FJException);
601	>	assertTrue(f.getException() instanceof FJException);
602	>	checkCompletedAbnormally(f, f.getException());
603		}};
604		testInvokeOnPool(mainPool(), a);
605		}
#	Line 476 | Line 608 | public class ForkJoinTaskTest extends JS
608		* invoke task throws exception when task cancelled
609		*/
610		public void testCancelledInvoke() {
611	<	RecursiveAction a = new RecursiveAction() {
612	<	public void compute() {
611	>	RecursiveAction a = new CheckedRecursiveAction() {
612	>	protected void realCompute() {
613	>	AsyncFib f = new AsyncFib(8);
614	>	assertTrue(f.cancel(true));
615		try {
482	–	AsyncFib f = new AsyncFib(8);
483	–	threadAssertTrue(f.cancel(true));
616		f.invoke();
617		shouldThrow();
618		} catch (CancellationException success) {
619	+	checkCancelled(f);
620		}
621		}};
622		testInvokeOnPool(mainPool(), a);
#	Line 493 | Line 626 | public class ForkJoinTaskTest extends JS
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() {
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 {
499	–	AsyncFib f = new AsyncFib(8);
500	–	threadAssertTrue(f.cancel(true));
501	–	threadAssertSame(f, f.fork());
635		f.join();
636		shouldThrow();
637		} catch (CancellationException success) {
638	+	checkCancelled(f);
639		}
640		}};
641		testInvokeOnPool(mainPool(), a);
#	Line 511 | Line 645 | public class ForkJoinTaskTest extends JS
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() {
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 {
517	–	AsyncFib f = new AsyncFib(8);
518	–	threadAssertTrue(f.cancel(true));
519	–	threadAssertSame(f, f.fork());
654		f.get();
655		shouldThrow();
656		} catch (CancellationException success) {
657	<	} catch (Exception ex) {
524	<	unexpectedException(ex);
657	>	checkCancelled(f);
658		}
659		}};
660		testInvokeOnPool(mainPool(), a);
#	Line 530 | Line 663 | public class ForkJoinTaskTest extends JS
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() {
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	<	AsyncFib f = new AsyncFib(8);
538	<	threadAssertTrue(f.cancel(true));
539	<	threadAssertSame(f, f.fork());
540	<	f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
673	>	f.get(LONG_DELAY_MS, MILLISECONDS);
674		shouldThrow();
675		} catch (CancellationException success) {
676	<	} catch (Exception ex) {
544	<	unexpectedException(ex);
676	>	checkCancelled(f);
677		}
678		}};
679		testInvokeOnPool(mainPool(), a);
#	Line 551 | Line 683 | public class ForkJoinTaskTest extends JS
683		* quietlyJoin of a forked task returns when task cancelled
684		*/
685		public void testCancelledForkQuietlyJoin() {
686	<	RecursiveAction a = new RecursiveAction() {
687	<	public void compute() {
686	>	RecursiveAction a = new CheckedRecursiveAction() {
687	>	protected void realCompute() {
688		AsyncFib f = new AsyncFib(8);
689	<	threadAssertTrue(f.cancel(true));
690	<	threadAssertSame(f, f.fork());
689	>	assertTrue(f.cancel(true));
690	>	assertSame(f, f.fork());
691		f.quietlyJoin();
692	<	threadAssertTrue(f.isDone());
561	<	threadAssertTrue(f.isCompletedAbnormally());
562	<	threadAssertTrue(f.getException() instanceof CancellationException);
692	>	checkCancelled(f);
693		}};
694		testInvokeOnPool(mainPool(), a);
695		}
#	Line 569 | Line 699 | public class ForkJoinTaskTest extends JS
699		*/
700		public void testGetPool() {
701		final ForkJoinPool mainPool = mainPool();
702	<	RecursiveAction a = new RecursiveAction() {
703	<	public void compute() {
704	<	threadAssertTrue(getPool() == mainPool);
702	>	RecursiveAction a = new CheckedRecursiveAction() {
703	>	protected void realCompute() {
704	>	assertSame(mainPool, getPool());
705		}};
706		testInvokeOnPool(mainPool, a);
707		}
#	Line 580 | Line 710 | public class ForkJoinTaskTest extends JS
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);
713	>	RecursiveAction a = new CheckedRecursiveAction() {
714	>	protected void realCompute() {
715	>	assertNull(getPool());
716		}};
717		assertNull(a.invoke());
718		}
#	Line 591 | Line 721 | public class ForkJoinTaskTest extends JS
721		* inForkJoinPool of executing task returns true
722		*/
723		public void testInForkJoinPool() {
724	<	RecursiveAction a = new RecursiveAction() {
725	<	public void compute() {
726	<	threadAssertTrue(inForkJoinPool());
724	>	RecursiveAction a = new CheckedRecursiveAction() {
725	>	protected void realCompute() {
726	>	assertTrue(inForkJoinPool());
727		}};
728		testInvokeOnPool(mainPool(), a);
729		}
#	Line 602 | Line 732 | public class ForkJoinTaskTest extends JS
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());
735	>	RecursiveAction a = new CheckedRecursiveAction() {
736	>	protected void realCompute() {
737	>	assertFalse(inForkJoinPool());
738		}};
739		assertNull(a.invoke());
740		}
#	Line 613 | Line 743 | public class ForkJoinTaskTest extends JS
743		* setRawResult(null) succeeds
744		*/
745		public void testSetRawResult() {
746	<	RecursiveAction a = new RecursiveAction() {
747	<	public void compute() {
746	>	RecursiveAction a = new CheckedRecursiveAction() {
747	>	protected void realCompute() {
748		setRawResult(null);
749	+	assertNull(getRawResult());
750		}};
751		assertNull(a.invoke());
752		}
#	Line 624 | Line 755 | public class ForkJoinTaskTest extends JS
755		* invoke task throws exception after invoking completeExceptionally
756		*/
757		public void testCompleteExceptionally() {
758	<	RecursiveAction a = new RecursiveAction() {
759	<	public void compute() {
758	>	RecursiveAction a = new CheckedRecursiveAction() {
759	>	protected void realCompute() {
760	>	AsyncFib f = new AsyncFib(8);
761	>	f.completeExceptionally(new FJException());
762		try {
630	–	AsyncFib f = new AsyncFib(8);
631	–	f.completeExceptionally(new FJException());
763		f.invoke();
764		shouldThrow();
765		} catch (FJException success) {
766	+	checkCompletedAbnormally(f, success);
767		}
768		}};
769		testInvokeOnPool(mainPool(), a);
#	Line 641 | Line 773 | public class ForkJoinTaskTest extends JS
773		* invokeAll(t1, t2) invokes all task arguments
774		*/
775		public void testInvokeAll2() {
776	<	RecursiveAction a = new RecursiveAction() {
777	<	public void compute() {
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	<	threadAssertTrue(f.isDone());
782	<	threadAssertTrue(f.number == 21);
783	<	threadAssertTrue(g.isDone());
784	<	threadAssertTrue(g.number == 34);
781	>	assertEquals(21, f.number);
782	>	assertEquals(34, g.number);
783	>	checkCompletedNormally(f);
784	>	checkCompletedNormally(g);
785		}};
786		testInvokeOnPool(mainPool(), a);
787		}
#	Line 658 | Line 790 | public class ForkJoinTaskTest extends JS
790		* invokeAll(tasks) with 1 argument invokes task
791		*/
792		public void testInvokeAll1() {
793	<	RecursiveAction a = new RecursiveAction() {
794	<	public void compute() {
793	>	RecursiveAction a = new CheckedRecursiveAction() {
794	>	protected void realCompute() {
795		AsyncFib f = new AsyncFib(8);
796		invokeAll(f);
797	<	threadAssertTrue(f.isDone());
798	<	threadAssertTrue(f.number == 21);
797	>	checkCompletedNormally(f);
798	>	assertEquals(21, f.number);
799		}};
800		testInvokeOnPool(mainPool(), a);
801		}
#	Line 672 | Line 804 | public class ForkJoinTaskTest extends JS
804		* invokeAll(tasks) with > 2 argument invokes tasks
805		*/
806		public void testInvokeAll3() {
807	<	RecursiveAction a = new RecursiveAction() {
808	<	public void compute() {
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	<	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);
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		}
#	Line 692 | Line 824 | public class ForkJoinTaskTest extends JS
824		* invokeAll(collection) invokes all tasks in the collection
825		*/
826		public void testInvokeAllCollection() {
827	<	RecursiveAction a = new RecursiveAction() {
828	<	public void compute() {
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);
#	Line 702 | Line 834 | public class ForkJoinTaskTest extends JS
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);
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
715	–
847		/**
848		* invokeAll(tasks) with any null task throws NPE
849		*/
850		public void testInvokeAllNPE() {
851	<	RecursiveAction a = new RecursiveAction() {
852	<	public void compute() {
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 {
723	–	AsyncFib f = new AsyncFib(8);
724	–	AsyncFib g = new AsyncFib(9);
725	–	AsyncFib h = null;
857		invokeAll(f, g, h);
858		shouldThrow();
859	<	} catch (NullPointerException success) {
729	<	}
859	>	} catch (NullPointerException success) {}
860		}};
861		testInvokeOnPool(mainPool(), a);
862		}
#	Line 735 | Line 865 | public class ForkJoinTaskTest extends JS
865		* invokeAll(t1, t2) throw exception if any task does
866		*/
867		public void testAbnormalInvokeAll2() {
868	<	RecursiveAction a = new RecursiveAction() {
869	<	public void compute() {
868	>	RecursiveAction a = new CheckedRecursiveAction() {
869	>	protected void realCompute() {
870	>	AsyncFib f = new AsyncFib(8);
871	>	FailingAsyncFib g = new FailingAsyncFib(9);
872		try {
741	–	AsyncFib f = new AsyncFib(8);
742	–	FailingAsyncFib g = new FailingAsyncFib(9);
873		invokeAll(f, g);
874		shouldThrow();
875		} catch (FJException success) {
876	+	checkCompletedAbnormally(g, success);
877		}
878		}};
879		testInvokeOnPool(mainPool(), a);
#	Line 752 | Line 883 | public class ForkJoinTaskTest extends JS
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() {
886	>	RecursiveAction a = new CheckedRecursiveAction() {
887	>	protected void realCompute() {
888	>	FailingAsyncFib g = new FailingAsyncFib(9);
889		try {
758	–	FailingAsyncFib g = new FailingAsyncFib(9);
890		invokeAll(g);
891		shouldThrow();
892		} catch (FJException success) {
893	+	checkCompletedAbnormally(g, success);
894		}
895		}};
896		testInvokeOnPool(mainPool(), a);
#	Line 768 | Line 900 | public class ForkJoinTaskTest extends JS
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() {
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 {
774	–	AsyncFib f = new AsyncFib(8);
775	–	FailingAsyncFib g = new FailingAsyncFib(9);
776	–	AsyncFib h = new AsyncFib(7);
909		invokeAll(f, g, h);
910		shouldThrow();
911		} catch (FJException success) {
912	+	checkCompletedAbnormally(g, success);
913		}
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() {
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 {
792	–	FailingAsyncFib f = new FailingAsyncFib(8);
793	–	AsyncFib g = new AsyncFib(9);
794	–	AsyncFib h = new AsyncFib(7);
795	–	HashSet set = new HashSet();
796	–	set.add(f);
797	–	set.add(g);
798	–	set.add(h);
932		invokeAll(set);
933		shouldThrow();
934		} catch (FJException success) {
935	+	checkCompletedAbnormally(f, success);
936		}
937		}};
938		testInvokeOnPool(mainPool(), a);
#	Line 809 | 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() {
946	>	RecursiveAction a = new CheckedRecursiveAction() {
947	>	protected void realCompute() {
948		AsyncFib g = new AsyncFib(9);
949	<	threadAssertSame(g, g.fork());
949	>	assertSame(g, g.fork());
950		AsyncFib f = new AsyncFib(8);
951	<	threadAssertSame(f, f.fork());
952	<	threadAssertTrue(f.tryUnfork());
951	>	assertSame(f, f.fork());
952	>	assertTrue(f.tryUnfork());
953		helpQuiesce();
954	<	threadAssertFalse(f.isDone());
955	<	threadAssertTrue(g.isDone());
954	>	checkNotDone(f);
955	>	checkCompletedNormally(g);
956		}};
957		testInvokeOnPool(singletonPool(), a);
958		}
#	Line 828 | 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() {
965	>	RecursiveAction a = new CheckedRecursiveAction() {
966	>	protected void realCompute() {
967		AsyncFib h = new AsyncFib(7);
968	<	threadAssertSame(h, h.fork());
968	>	assertSame(h, h.fork());
969		AsyncFib g = new AsyncFib(9);
970	<	threadAssertSame(g, g.fork());
970	>	assertSame(g, g.fork());
971		AsyncFib f = new AsyncFib(8);
972	<	threadAssertSame(f, f.fork());
973	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
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		}
#	Line 846 | Line 984 | public class ForkJoinTaskTest extends JS
984		* peekNextLocalTask returns most recent unexecuted task.
985		*/
986		public void testPeekNextLocalTask() {
987	<	RecursiveAction a = new RecursiveAction() {
988	<	public void compute() {
987	>	RecursiveAction a = new CheckedRecursiveAction() {
988	>	protected void realCompute() {
989		AsyncFib g = new AsyncFib(9);
990	<	threadAssertSame(g, g.fork());
990	>	assertSame(g, g.fork());
991		AsyncFib f = new AsyncFib(8);
992	<	threadAssertSame(f, f.fork());
993	<	threadAssertTrue(peekNextLocalTask() == f);
994	<	threadAssertNull(f.join());
995	<	threadAssertTrue(f.isDone());
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() {
1007	>	RecursiveAction a = new CheckedRecursiveAction() {
1008	>	protected void realCompute() {
1009		AsyncFib g = new AsyncFib(9);
1010	<	threadAssertSame(g, g.fork());
1010	>	assertSame(g, g.fork());
1011		AsyncFib f = new AsyncFib(8);
1012	<	threadAssertSame(f, f.fork());
1013	<	threadAssertTrue(pollNextLocalTask() == f);
1012	>	assertSame(f, f.fork());
1013	>	assertSame(f, pollNextLocalTask());
1014		helpQuiesce();
1015	<	threadAssertFalse(f.isDone());
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
883	<	* 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() {
1026	>	RecursiveAction a = new CheckedRecursiveAction() {
1027	>	protected void realCompute() {
1028		AsyncFib g = new AsyncFib(9);
1029	<	threadAssertSame(g, g.fork());
1029	>	assertSame(g, g.fork());
1030		AsyncFib f = new AsyncFib(8);
1031	<	threadAssertSame(f, f.fork());
1032	<	threadAssertTrue(pollTask() == f);
1031	>	assertSame(f, f.fork());
1032	>	assertSame(f, pollTask());
1033		helpQuiesce();
1034	<	threadAssertFalse(f.isDone());
1035	<	threadAssertTrue(g.isDone());
1034	>	checkNotDone(f);
1035	>	checkCompletedNormally(g);
1036		}};
1037		testInvokeOnPool(singletonPool(), a);
1038		}
#	Line 901 | Line 1041 | public class ForkJoinTaskTest extends JS
1041		* peekNextLocalTask returns least recent unexecuted task in async mode
1042		*/
1043		public void testPeekNextLocalTaskAsync() {
1044	<	RecursiveAction a = new RecursiveAction() {
1045	<	public void compute() {
1044	>	RecursiveAction a = new CheckedRecursiveAction() {
1045	>	protected void realCompute() {
1046		AsyncFib g = new AsyncFib(9);
1047	<	threadAssertSame(g, g.fork());
1047	>	assertSame(g, g.fork());
1048		AsyncFib f = new AsyncFib(8);
1049	<	threadAssertSame(f, f.fork());
1050	<	threadAssertTrue(peekNextLocalTask() == g);
1051	<	threadAssertNull(f.join());
1049	>	assertSame(f, f.fork());
1050	>	assertSame(g, peekNextLocalTask());
1051	>	assertNull(f.join());
1052		helpQuiesce();
1053	<	threadAssertTrue(f.isDone());
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
1062	<	* without executing it, in async mode
1061	>	* pollNextLocalTask returns least recent unexecuted task without
1062	>	* executing it, in async mode
1063		*/
1064		public void testPollNextLocalTaskAsync() {
1065	<	RecursiveAction a = new RecursiveAction() {
1066	<	public void compute() {
1065	>	RecursiveAction a = new CheckedRecursiveAction() {
1066	>	protected void realCompute() {
1067		AsyncFib g = new AsyncFib(9);
1068	<	threadAssertSame(g, g.fork());
1068	>	assertSame(g, g.fork());
1069		AsyncFib f = new AsyncFib(8);
1070	<	threadAssertSame(f, f.fork());
1071	<	threadAssertTrue(pollNextLocalTask() == g);
1070	>	assertSame(f, f.fork());
1071	>	assertSame(g, pollNextLocalTask());
1072		helpQuiesce();
1073	<	threadAssertTrue(f.isDone());
1074	<	threadAssertFalse(g.isDone());
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
1082	<	* without executing it, in async mode
1081	>	* pollTask returns an unexecuted task without executing it, in
1082	>	* async mode
1083		*/
1084		public void testPollTaskAsync() {
1085	<	RecursiveAction a = new RecursiveAction() {
1086	<	public void compute() {
1085	>	RecursiveAction a = new CheckedRecursiveAction() {
1086	>	protected void realCompute() {
1087		AsyncFib g = new AsyncFib(9);
1088	<	threadAssertSame(g, g.fork());
1088	>	assertSame(g, g.fork());
1089		AsyncFib f = new AsyncFib(8);
1090	<	threadAssertSame(f, f.fork());
1091	<	threadAssertTrue(pollTask() == g);
1090	>	assertSame(f, f.fork());
1091	>	assertSame(g, pollTask());
1092		helpQuiesce();
1093	<	threadAssertTrue(f.isDone());
1094	<	threadAssertFalse(g.isDone());
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	+	shouldThrow();
1269	+	} catch (FJException success) {
1270	+	checkCompletedAbnormally(f, success);
1271	+	}
1272	+	}};
1273	+	testInvokeOnPool(singletonPool(), a);
1274	+	}
1275	+
1276	+	/**
1277	+	* get of a forked task throws exception when task completes abnormally
1278	+	*/
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	+	testInvokeOnPool(singletonPool(), a);
1294	+	}
1295	+
1296	+	/**
1297	+	* timed get of a forked task throws exception when task completes abnormally
1298	+	*/
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	+	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