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.23 by jsr166, Sun Nov 21 07:45:00 2010 UTC vs.
Revision 1.51 by jsr166, Wed Aug 24 22:22:39 2016 UTC

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

Diff Legend

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