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.29 by jsr166, Tue Nov 23 06:33:26 2010 UTC vs.
Revision 1.49 by jsr166, Sun Oct 18 16:40:57 2015 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.Collections;
12	>	import java.util.HashSet;
13	>	import java.util.List;
14		import java.util.concurrent.CancellationException;
15	+	import java.util.concurrent.ExecutionException;
16		import java.util.concurrent.ForkJoinPool;
17		import java.util.concurrent.ForkJoinTask;
10	–	import java.util.concurrent.ForkJoinWorkerThread;
18		import java.util.concurrent.RecursiveAction;
12	–	import java.util.concurrent.TimeUnit;
19		import java.util.concurrent.TimeoutException;
20		import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
21	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
22	<	import static java.util.concurrent.TimeUnit.SECONDS;
23	<	import java.util.HashSet;
18	<	import junit.framework.*;
21	>
22	>	import junit.framework.Test;
23	>	import junit.framework.TestSuite;
24
25		public class ForkJoinTaskTest extends JSR166TestCase {
26
27		public static void main(String[] args) {
28	<	junit.textui.TestRunner.run(suite());
28	>	main(suite(), args);
29		}
30
31		public static Test suite() {
#	Line 46 | Line 51 | public class ForkJoinTaskTest extends JS
51		}
52
53		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
54	<	try {
54	>	try (PoolCleaner cleaner = cleaner(pool)) {
55		assertFalse(a.isDone());
56		assertFalse(a.isCompletedNormally());
57		assertFalse(a.isCompletedAbnormally());
#	Line 62 | Line 67 | public class ForkJoinTaskTest extends JS
67		assertFalse(a.isCancelled());
68		assertNull(a.getException());
69		assertNull(a.getRawResult());
65	–	} finally {
66	–	joinPool(pool);
70		}
71		}
72
#	Line 96 | Line 99 | public class ForkJoinTaskTest extends JS
99
100		{
101		Thread.currentThread().interrupt();
102	<	long t0 = System.nanoTime();
102	>	long startTime = System.nanoTime();
103		assertSame(expected, a.join());
104	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
104	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
105		Thread.interrupted();
106		}
107
108		{
109		Thread.currentThread().interrupt();
110	<	long t0 = System.nanoTime();
110	>	long startTime = System.nanoTime();
111		a.quietlyJoin();        // should be no-op
112	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
112	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
113		Thread.interrupted();
114		}
115
#	Line 139 | Line 142 | public class ForkJoinTaskTest extends JS
142		Thread.interrupted();
143
144		{
145	<	long t0 = System.nanoTime();
145	>	long startTime = System.nanoTime();
146		a.quietlyJoin();        // should be no-op
147	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
147	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
148		}
149
150		try {
#	Line 162 | Line 165 | public class ForkJoinTaskTest extends JS
165		assertFalse(a.isCancelled());
166		assertFalse(a.isCompletedNormally());
167		assertTrue(a.isCompletedAbnormally());
168	<	assertSame(t, a.getException());
168	>	assertSame(t.getClass(), a.getException().getClass());
169		assertNull(a.getRawResult());
170		assertFalse(a.cancel(false));
171		assertFalse(a.cancel(true));
#	Line 172 | Line 175 | public class ForkJoinTaskTest extends JS
175		a.join();
176		shouldThrow();
177		} catch (Throwable expected) {
178	<	assertSame(t, expected);
178	>	assertSame(t.getClass(), expected.getClass());
179		}
180		Thread.interrupted();
181
182		{
183	<	long t0 = System.nanoTime();
183	>	long startTime = System.nanoTime();
184		a.quietlyJoin();        // should be no-op
185	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
185	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
186		}
187
188		try {
189		a.get();
190		shouldThrow();
191		} catch (ExecutionException success) {
192	<	assertSame(t, success.getCause());
192	>	assertSame(t.getClass(), success.getCause().getClass());
193		} catch (Throwable fail) { threadUnexpectedException(fail); }
194
195		try {
196		a.get(5L, SECONDS);
197		shouldThrow();
198		} catch (ExecutionException success) {
199	<	assertSame(t, success.getCause());
199	>	assertSame(t.getClass(), success.getCause().getClass());
200		} catch (Throwable fail) { threadUnexpectedException(fail); }
201		}
202
#	Line 205 | Line 208 | public class ForkJoinTaskTest extends JS
208		* differently than supplied Recursive forms.
209		*/
210
211	<	static final class FJException extends RuntimeException {
211	>	public static final class FJException extends RuntimeException {
212		FJException() { super(); }
213		}
214
#	Line 216 | Line 219 | public class ForkJoinTaskTest extends JS
219		AtomicIntegerFieldUpdater.newUpdater(BinaryAsyncAction.class,
220		"controlState");
221
222	<	private BinaryAsyncAction parent;
222	>	private volatile BinaryAsyncAction parent;
223
224	<	private BinaryAsyncAction sibling;
224	>	private volatile BinaryAsyncAction sibling;
225
226		protected BinaryAsyncAction() {
227		}
#	Line 253 | Line 256 | public class ForkJoinTaskTest extends JS
256		super.completeExceptionally(ex);
257		}
258
259	+	public boolean cancel(boolean mayInterruptIfRunning) {
260	+	if (super.cancel(mayInterruptIfRunning)) {
261	+	completeExceptionally(new FJException());
262	+	return true;
263	+	}
264	+	return false;
265	+	}
266	+
267		public final void complete() {
268		BinaryAsyncAction a = this;
269		for (;;) {
#	Line 274 | Line 285 | public class ForkJoinTaskTest extends JS
285		}
286
287		public final void completeExceptionally(Throwable ex) {
288	<	BinaryAsyncAction a = this;
278	<	while (!a.isCompletedAbnormally()) {
288	>	for (BinaryAsyncAction a = this;;) {
289		a.completeThisExceptionally(ex);
290		BinaryAsyncAction s = a.sibling;
291	<	if (s != null)
292	<	s.cancel(false);
293	<	if (!a.onException() || (a = a.parent) == null)
291	>	if (s != null && !s.isDone())
292	>	s.completeExceptionally(ex);
293	>	if ((a = a.parent) == null)
294		break;
295		}
296		}
#	Line 330 | Line 340 | public class ForkJoinTaskTest extends JS
340		public final boolean exec() {
341		AsyncFib f = this;
342		int n = f.number;
343	<	if (n > 1) {
344	<	while (n > 1) {
345	<	AsyncFib p = f;
346	<	AsyncFib r = new AsyncFib(n - 2);
347	<	f = new AsyncFib(--n);
348	<	p.linkSubtasks(r, f);
339	<	r.fork();
340	<	}
341	<	f.number = n;
343	>	while (n > 1) {
344	>	AsyncFib p = f;
345	>	AsyncFib r = new AsyncFib(n - 2);
346	>	f = new AsyncFib(--n);
347	>	p.linkSubtasks(r, f);
348	>	r.fork();
349		}
350		f.complete();
351		return false;
#	Line 349 | Line 356 | public class ForkJoinTaskTest extends JS
356		}
357		}
358
352	–
359		static final class FailingAsyncFib extends BinaryAsyncAction {
360		int number;
361		public FailingAsyncFib(int n) {
#	Line 359 | Line 365 | public class ForkJoinTaskTest extends JS
365		public final boolean exec() {
366		FailingAsyncFib f = this;
367		int n = f.number;
368	<	if (n > 1) {
369	<	while (n > 1) {
370	<	FailingAsyncFib p = f;
371	<	FailingAsyncFib r = new FailingAsyncFib(n - 2);
372	<	f = new FailingAsyncFib(--n);
373	<	p.linkSubtasks(r, f);
368	<	r.fork();
369	<	}
370	<	f.number = n;
368	>	while (n > 1) {
369	>	FailingAsyncFib p = f;
370	>	FailingAsyncFib r = new FailingAsyncFib(n - 2);
371	>	f = new FailingAsyncFib(--n);
372	>	p.linkSubtasks(r, f);
373	>	r.fork();
374		}
375		f.complete();
376		return false;
#	Line 385 | Line 388 | public class ForkJoinTaskTest extends JS
388		*/
389		public void testInvoke() {
390		RecursiveAction a = new CheckedRecursiveAction() {
391	<	public void realCompute() {
391	>	protected void realCompute() {
392		AsyncFib f = new AsyncFib(8);
393		assertNull(f.invoke());
394		assertEquals(21, f.number);
#	Line 401 | Line 404 | public class ForkJoinTaskTest extends JS
404		*/
405		public void testQuietlyInvoke() {
406		RecursiveAction a = new CheckedRecursiveAction() {
407	<	public void realCompute() {
407	>	protected void realCompute() {
408		AsyncFib f = new AsyncFib(8);
409		f.quietlyInvoke();
410		assertEquals(21, f.number);
#	Line 415 | Line 418 | public class ForkJoinTaskTest extends JS
418		*/
419		public void testForkJoin() {
420		RecursiveAction a = new CheckedRecursiveAction() {
421	<	public void realCompute() {
421	>	protected void realCompute() {
422		AsyncFib f = new AsyncFib(8);
423		assertSame(f, f.fork());
424		assertNull(f.join());
#	Line 430 | Line 433 | public class ForkJoinTaskTest extends JS
433		*/
434		public void testForkGet() {
435		RecursiveAction a = new CheckedRecursiveAction() {
436	<	public void realCompute() throws Exception {
436	>	protected void realCompute() throws Exception {
437		AsyncFib f = new AsyncFib(8);
438		assertSame(f, f.fork());
439		assertNull(f.get());
#	Line 445 | Line 448 | public class ForkJoinTaskTest extends JS
448		*/
449		public void testForkTimedGet() {
450		RecursiveAction a = new CheckedRecursiveAction() {
451	<	public void realCompute() throws Exception {
451	>	protected void realCompute() throws Exception {
452		AsyncFib f = new AsyncFib(8);
453		assertSame(f, f.fork());
454		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
#	Line 460 | Line 463 | public class ForkJoinTaskTest extends JS
463		*/
464		public void testForkTimedGetNPE() {
465		RecursiveAction a = new CheckedRecursiveAction() {
466	<	public void realCompute() throws Exception {
466	>	protected void realCompute() throws Exception {
467		AsyncFib f = new AsyncFib(8);
468		assertSame(f, f.fork());
469		try {
#	Line 476 | Line 479 | public class ForkJoinTaskTest extends JS
479		*/
480		public void testForkQuietlyJoin() {
481		RecursiveAction a = new CheckedRecursiveAction() {
482	<	public void realCompute() {
482	>	protected void realCompute() {
483		AsyncFib f = new AsyncFib(8);
484		assertSame(f, f.fork());
485		f.quietlyJoin();
#	Line 486 | Line 489 | public class ForkJoinTaskTest extends JS
489		testInvokeOnPool(mainPool(), a);
490		}
491
489	–
492		/**
493		* helpQuiesce returns when tasks are complete.
494		* getQueuedTaskCount returns 0 when quiescent
495		*/
496		public void testForkHelpQuiesce() {
497		RecursiveAction a = new CheckedRecursiveAction() {
498	<	public void realCompute() {
498	>	protected void realCompute() {
499		AsyncFib f = new AsyncFib(8);
500		assertSame(f, f.fork());
501	<	f.helpQuiesce();
501	>	helpQuiesce();
502		assertEquals(21, f.number);
503		assertEquals(0, getQueuedTaskCount());
504		checkCompletedNormally(f);
#	Line 504 | Line 506 | public class ForkJoinTaskTest extends JS
506		testInvokeOnPool(mainPool(), a);
507		}
508
507	–
509		/**
510		* invoke task throws exception when task completes abnormally
511		*/
512		public void testAbnormalInvoke() {
513		RecursiveAction a = new CheckedRecursiveAction() {
514	<	public void realCompute() {
514	>	protected void realCompute() {
515		FailingAsyncFib f = new FailingAsyncFib(8);
516		try {
517		f.invoke();
#	Line 527 | Line 528 | public class ForkJoinTaskTest extends JS
528		*/
529		public void testAbnormalQuietlyInvoke() {
530		RecursiveAction a = new CheckedRecursiveAction() {
531	<	public void realCompute() {
531	>	protected void realCompute() {
532		FailingAsyncFib f = new FailingAsyncFib(8);
533		f.quietlyInvoke();
534		assertTrue(f.getException() instanceof FJException);
#	Line 541 | Line 542 | public class ForkJoinTaskTest extends JS
542		*/
543		public void testAbnormalForkJoin() {
544		RecursiveAction a = new CheckedRecursiveAction() {
545	<	public void realCompute() {
545	>	protected void realCompute() {
546		FailingAsyncFib f = new FailingAsyncFib(8);
547		assertSame(f, f.fork());
548		try {
#	Line 559 | Line 560 | public class ForkJoinTaskTest extends JS
560		*/
561		public void testAbnormalForkGet() {
562		RecursiveAction a = new CheckedRecursiveAction() {
563	<	public void realCompute() throws Exception {
563	>	protected void realCompute() throws Exception {
564		FailingAsyncFib f = new FailingAsyncFib(8);
565		assertSame(f, f.fork());
566		try {
#	Line 579 | Line 580 | public class ForkJoinTaskTest extends JS
580		*/
581		public void testAbnormalForkTimedGet() {
582		RecursiveAction a = new CheckedRecursiveAction() {
583	<	public void realCompute() throws Exception {
583	>	protected void realCompute() throws Exception {
584		FailingAsyncFib f = new FailingAsyncFib(8);
585		assertSame(f, f.fork());
586		try {
#	Line 599 | Line 600 | public class ForkJoinTaskTest extends JS
600		*/
601		public void testAbnormalForkQuietlyJoin() {
602		RecursiveAction a = new CheckedRecursiveAction() {
603	<	public void realCompute() {
603	>	protected void realCompute() {
604		FailingAsyncFib f = new FailingAsyncFib(8);
605		assertSame(f, f.fork());
606		f.quietlyJoin();
#	Line 614 | Line 615 | public class ForkJoinTaskTest extends JS
615		*/
616		public void testCancelledInvoke() {
617		RecursiveAction a = new CheckedRecursiveAction() {
618	<	public void realCompute() {
618	>	protected void realCompute() {
619		AsyncFib f = new AsyncFib(8);
620		assertTrue(f.cancel(true));
621		try {
#	Line 632 | Line 633 | public class ForkJoinTaskTest extends JS
633		*/
634		public void testCancelledForkJoin() {
635		RecursiveAction a = new CheckedRecursiveAction() {
636	<	public void realCompute() {
636	>	protected void realCompute() {
637		AsyncFib f = new AsyncFib(8);
638		assertTrue(f.cancel(true));
639		assertSame(f, f.fork());
#	Line 651 | Line 652 | public class ForkJoinTaskTest extends JS
652		*/
653		public void testCancelledForkGet() {
654		RecursiveAction a = new CheckedRecursiveAction() {
655	<	public void realCompute() throws Exception {
655	>	protected void realCompute() throws Exception {
656		AsyncFib f = new AsyncFib(8);
657		assertTrue(f.cancel(true));
658		assertSame(f, f.fork());
#	Line 670 | Line 671 | public class ForkJoinTaskTest extends JS
671		*/
672		public void testCancelledForkTimedGet() throws Exception {
673		RecursiveAction a = new CheckedRecursiveAction() {
674	<	public void realCompute() throws Exception {
674	>	protected void realCompute() throws Exception {
675		AsyncFib f = new AsyncFib(8);
676		assertTrue(f.cancel(true));
677		assertSame(f, f.fork());
#	Line 689 | Line 690 | public class ForkJoinTaskTest extends JS
690		*/
691		public void testCancelledForkQuietlyJoin() {
692		RecursiveAction a = new CheckedRecursiveAction() {
693	<	public void realCompute() {
693	>	protected void realCompute() {
694		AsyncFib f = new AsyncFib(8);
695		assertTrue(f.cancel(true));
696		assertSame(f, f.fork());
#	Line 705 | Line 706 | public class ForkJoinTaskTest extends JS
706		public void testGetPool() {
707		final ForkJoinPool mainPool = mainPool();
708		RecursiveAction a = new CheckedRecursiveAction() {
709	<	public void realCompute() {
709	>	protected void realCompute() {
710		assertSame(mainPool, getPool());
711		}};
712		testInvokeOnPool(mainPool, a);
#	Line 716 | Line 717 | public class ForkJoinTaskTest extends JS
717		*/
718		public void testGetPool2() {
719		RecursiveAction a = new CheckedRecursiveAction() {
720	<	public void realCompute() {
720	>	protected void realCompute() {
721		assertNull(getPool());
722		}};
723		assertNull(a.invoke());
#	Line 727 | Line 728 | public class ForkJoinTaskTest extends JS
728		*/
729		public void testInForkJoinPool() {
730		RecursiveAction a = new CheckedRecursiveAction() {
731	<	public void realCompute() {
731	>	protected void realCompute() {
732		assertTrue(inForkJoinPool());
733		}};
734		testInvokeOnPool(mainPool(), a);
#	Line 738 | Line 739 | public class ForkJoinTaskTest extends JS
739		*/
740		public void testInForkJoinPool2() {
741		RecursiveAction a = new CheckedRecursiveAction() {
742	<	public void realCompute() {
742	>	protected void realCompute() {
743		assertFalse(inForkJoinPool());
744		}};
745		assertNull(a.invoke());
#	Line 749 | Line 750 | public class ForkJoinTaskTest extends JS
750		*/
751		public void testSetRawResult() {
752		RecursiveAction a = new CheckedRecursiveAction() {
753	<	public void realCompute() {
753	>	protected void realCompute() {
754		setRawResult(null);
755		assertNull(getRawResult());
756		}};
#	Line 761 | Line 762 | public class ForkJoinTaskTest extends JS
762		*/
763		public void testCompleteExceptionally() {
764		RecursiveAction a = new CheckedRecursiveAction() {
765	<	public void realCompute() {
765	>	protected void realCompute() {
766		AsyncFib f = new AsyncFib(8);
767		f.completeExceptionally(new FJException());
768		try {
#	Line 775 | Line 776 | public class ForkJoinTaskTest extends JS
776		}
777
778		/**
779	+	* completeExceptionally(null) surprisingly has the same effect as
780	+	* completeExceptionally(new RuntimeException())
781	+	*/
782	+	public void testCompleteExceptionally_null() {
783	+	RecursiveAction a = new CheckedRecursiveAction() {
784	+	protected void realCompute() {
785	+	AsyncFib f = new AsyncFib(8);
786	+	f.completeExceptionally(null);
787	+	try {
788	+	f.invoke();
789	+	shouldThrow();
790	+	} catch (RuntimeException success) {
791	+	assertSame(success.getClass(), RuntimeException.class);
792	+	assertNull(success.getCause());
793	+	checkCompletedAbnormally(f, success);
794	+	}
795	+	}};
796	+	testInvokeOnPool(mainPool(), a);
797	+	}
798	+
799	+	/**
800		* invokeAll(t1, t2) invokes all task arguments
801		*/
802		public void testInvokeAll2() {
803		RecursiveAction a = new CheckedRecursiveAction() {
804	<	public void realCompute() {
804	>	protected void realCompute() {
805		AsyncFib f = new AsyncFib(8);
806		AsyncFib g = new AsyncFib(9);
807		invokeAll(f, g);
#	Line 796 | Line 818 | public class ForkJoinTaskTest extends JS
818		*/
819		public void testInvokeAll1() {
820		RecursiveAction a = new CheckedRecursiveAction() {
821	<	public void realCompute() {
821	>	protected void realCompute() {
822		AsyncFib f = new AsyncFib(8);
823		invokeAll(f);
824		checkCompletedNormally(f);
#	Line 810 | Line 832 | public class ForkJoinTaskTest extends JS
832		*/
833		public void testInvokeAll3() {
834		RecursiveAction a = new CheckedRecursiveAction() {
835	<	public void realCompute() {
835	>	protected void realCompute() {
836		AsyncFib f = new AsyncFib(8);
837		AsyncFib g = new AsyncFib(9);
838		AsyncFib h = new AsyncFib(7);
#	Line 830 | Line 852 | public class ForkJoinTaskTest extends JS
852		*/
853		public void testInvokeAllCollection() {
854		RecursiveAction a = new CheckedRecursiveAction() {
855	<	public void realCompute() {
855	>	protected void realCompute() {
856		AsyncFib f = new AsyncFib(8);
857		AsyncFib g = new AsyncFib(9);
858		AsyncFib h = new AsyncFib(7);
#	Line 849 | Line 871 | public class ForkJoinTaskTest extends JS
871		testInvokeOnPool(mainPool(), a);
872		}
873
852	–
874		/**
875		* invokeAll(tasks) with any null task throws NPE
876		*/
877		public void testInvokeAllNPE() {
878		RecursiveAction a = new CheckedRecursiveAction() {
879	<	public void realCompute() {
879	>	protected void realCompute() {
880		AsyncFib f = new AsyncFib(8);
881		AsyncFib g = new AsyncFib(9);
882		AsyncFib h = null;
#	Line 872 | Line 893 | public class ForkJoinTaskTest extends JS
893		*/
894		public void testAbnormalInvokeAll2() {
895		RecursiveAction a = new CheckedRecursiveAction() {
896	<	public void realCompute() {
896	>	protected void realCompute() {
897		AsyncFib f = new AsyncFib(8);
898		FailingAsyncFib g = new FailingAsyncFib(9);
899	+	ForkJoinTask[] tasks = { f, g };
900	+	Collections.shuffle(Arrays.asList(tasks));
901		try {
902	<	invokeAll(f, g);
902	>	invokeAll(tasks);
903		shouldThrow();
904		} catch (FJException success) {
905		checkCompletedAbnormally(g, success);
#	Line 890 | Line 913 | public class ForkJoinTaskTest extends JS
913		*/
914		public void testAbnormalInvokeAll1() {
915		RecursiveAction a = new CheckedRecursiveAction() {
916	<	public void realCompute() {
916	>	protected void realCompute() {
917		FailingAsyncFib g = new FailingAsyncFib(9);
918		try {
919		invokeAll(g);
#	Line 907 | Line 930 | public class ForkJoinTaskTest extends JS
930		*/
931		public void testAbnormalInvokeAll3() {
932		RecursiveAction a = new CheckedRecursiveAction() {
933	<	public void realCompute() {
933	>	protected void realCompute() {
934		AsyncFib f = new AsyncFib(8);
935		FailingAsyncFib g = new FailingAsyncFib(9);
936		AsyncFib h = new AsyncFib(7);
937	+	ForkJoinTask[] tasks = { f, g, h };
938	+	Collections.shuffle(Arrays.asList(tasks));
939		try {
940	<	invokeAll(f, g, h);
940	>	invokeAll(tasks);
941		shouldThrow();
942		} catch (FJException success) {
943		checkCompletedAbnormally(g, success);
#	Line 922 | Line 947 | public class ForkJoinTaskTest extends JS
947		}
948
949		/**
950	<	* invokeAll(collection)  throws exception if any task does
950	>	* invokeAll(collection) throws exception if any task does
951		*/
952		public void testAbnormalInvokeAllCollection() {
953		RecursiveAction a = new CheckedRecursiveAction() {
954	<	public void realCompute() {
954	>	protected void realCompute() {
955		FailingAsyncFib f = new FailingAsyncFib(8);
956		AsyncFib g = new AsyncFib(9);
957		AsyncFib h = new AsyncFib(7);
958	<	HashSet set = new HashSet();
959	<	set.add(f);
960	<	set.add(g);
936	<	set.add(h);
958	>	ForkJoinTask[] tasks = { f, g, h };
959	>	List taskList = Arrays.asList(tasks);
960	>	Collections.shuffle(taskList);
961		try {
962	<	invokeAll(set);
962	>	invokeAll(taskList);
963		shouldThrow();
964		} catch (FJException success) {
965		checkCompletedAbnormally(f, success);
#	Line 950 | Line 974 | public class ForkJoinTaskTest extends JS
974		*/
975		public void testTryUnfork() {
976		RecursiveAction a = new CheckedRecursiveAction() {
977	<	public void realCompute() {
977	>	protected void realCompute() {
978		AsyncFib g = new AsyncFib(9);
979		assertSame(g, g.fork());
980		AsyncFib f = new AsyncFib(8);
#	Line 969 | Line 993 | public class ForkJoinTaskTest extends JS
993		*/
994		public void testGetSurplusQueuedTaskCount() {
995		RecursiveAction a = new CheckedRecursiveAction() {
996	<	public void realCompute() {
996	>	protected void realCompute() {
997		AsyncFib h = new AsyncFib(7);
998		assertSame(h, h.fork());
999		AsyncFib g = new AsyncFib(9);
#	Line 991 | Line 1015 | public class ForkJoinTaskTest extends JS
1015		*/
1016		public void testPeekNextLocalTask() {
1017		RecursiveAction a = new CheckedRecursiveAction() {
1018	<	public void realCompute() {
1018	>	protected void realCompute() {
1019		AsyncFib g = new AsyncFib(9);
1020		assertSame(g, g.fork());
1021		AsyncFib f = new AsyncFib(8);
#	Line 1011 | Line 1035 | public class ForkJoinTaskTest extends JS
1035		*/
1036		public void testPollNextLocalTask() {
1037		RecursiveAction a = new CheckedRecursiveAction() {
1038	<	public void realCompute() {
1038	>	protected void realCompute() {
1039		AsyncFib g = new AsyncFib(9);
1040		assertSame(g, g.fork());
1041		AsyncFib f = new AsyncFib(8);
#	Line 1030 | Line 1054 | public class ForkJoinTaskTest extends JS
1054		*/
1055		public void testPollTask() {
1056		RecursiveAction a = new CheckedRecursiveAction() {
1057	<	public void realCompute() {
1057	>	protected void realCompute() {
1058		AsyncFib g = new AsyncFib(9);
1059		assertSame(g, g.fork());
1060		AsyncFib f = new AsyncFib(8);
#	Line 1048 | Line 1072 | public class ForkJoinTaskTest extends JS
1072		*/
1073		public void testPeekNextLocalTaskAsync() {
1074		RecursiveAction a = new CheckedRecursiveAction() {
1075	<	public void realCompute() {
1075	>	protected void realCompute() {
1076		AsyncFib g = new AsyncFib(9);
1077		assertSame(g, g.fork());
1078		AsyncFib f = new AsyncFib(8);
#	Line 1069 | Line 1093 | public class ForkJoinTaskTest extends JS
1093		*/
1094		public void testPollNextLocalTaskAsync() {
1095		RecursiveAction a = new CheckedRecursiveAction() {
1096	<	public void realCompute() {
1096	>	protected void realCompute() {
1097		AsyncFib g = new AsyncFib(9);
1098		assertSame(g, g.fork());
1099		AsyncFib f = new AsyncFib(8);
#	Line 1089 | Line 1113 | public class ForkJoinTaskTest extends JS
1113		*/
1114		public void testPollTaskAsync() {
1115		RecursiveAction a = new CheckedRecursiveAction() {
1116	<	public void realCompute() {
1116	>	protected void realCompute() {
1117		AsyncFib g = new AsyncFib(9);
1118		assertSame(g, g.fork());
1119		AsyncFib f = new AsyncFib(8);
#	Line 1112 | Line 1136 | public class ForkJoinTaskTest extends JS
1136		*/
1137		public void testInvokeSingleton() {
1138		RecursiveAction a = new CheckedRecursiveAction() {
1139	<	public void realCompute() {
1139	>	protected void realCompute() {
1140		AsyncFib f = new AsyncFib(8);
1141		assertNull(f.invoke());
1142		assertEquals(21, f.number);
#	Line 1128 | Line 1152 | public class ForkJoinTaskTest extends JS
1152		*/
1153		public void testQuietlyInvokeSingleton() {
1154		RecursiveAction a = new CheckedRecursiveAction() {
1155	<	public void realCompute() {
1155	>	protected void realCompute() {
1156		AsyncFib f = new AsyncFib(8);
1157		f.quietlyInvoke();
1158		assertEquals(21, f.number);
#	Line 1142 | Line 1166 | public class ForkJoinTaskTest extends JS
1166		*/
1167		public void testForkJoinSingleton() {
1168		RecursiveAction a = new CheckedRecursiveAction() {
1169	<	public void realCompute() {
1169	>	protected void realCompute() {
1170		AsyncFib f = new AsyncFib(8);
1171		assertSame(f, f.fork());
1172		assertNull(f.join());
#	Line 1157 | Line 1181 | public class ForkJoinTaskTest extends JS
1181		*/
1182		public void testForkGetSingleton() {
1183		RecursiveAction a = new CheckedRecursiveAction() {
1184	<	public void realCompute() throws Exception {
1184	>	protected void realCompute() throws Exception {
1185		AsyncFib f = new AsyncFib(8);
1186		assertSame(f, f.fork());
1187		assertNull(f.get());
#	Line 1172 | Line 1196 | public class ForkJoinTaskTest extends JS
1196		*/
1197		public void testForkTimedGetSingleton() {
1198		RecursiveAction a = new CheckedRecursiveAction() {
1199	<	public void realCompute() throws Exception {
1199	>	protected void realCompute() throws Exception {
1200		AsyncFib f = new AsyncFib(8);
1201		assertSame(f, f.fork());
1202		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
#	Line 1187 | Line 1211 | public class ForkJoinTaskTest extends JS
1211		*/
1212		public void testForkTimedGetNPESingleton() {
1213		RecursiveAction a = new CheckedRecursiveAction() {
1214	<	public void realCompute() throws Exception {
1214	>	protected void realCompute() throws Exception {
1215		AsyncFib f = new AsyncFib(8);
1216		assertSame(f, f.fork());
1217		try {
#	Line 1203 | Line 1227 | public class ForkJoinTaskTest extends JS
1227		*/
1228		public void testForkQuietlyJoinSingleton() {
1229		RecursiveAction a = new CheckedRecursiveAction() {
1230	<	public void realCompute() {
1230	>	protected void realCompute() {
1231		AsyncFib f = new AsyncFib(8);
1232		assertSame(f, f.fork());
1233		f.quietlyJoin();
#	Line 1213 | Line 1237 | public class ForkJoinTaskTest extends JS
1237		testInvokeOnPool(singletonPool(), a);
1238		}
1239
1216	–
1240		/**
1241		* helpQuiesce returns when tasks are complete.
1242		* getQueuedTaskCount returns 0 when quiescent
1243		*/
1244		public void testForkHelpQuiesceSingleton() {
1245		RecursiveAction a = new CheckedRecursiveAction() {
1246	<	public void realCompute() {
1246	>	protected void realCompute() {
1247		AsyncFib f = new AsyncFib(8);
1248		assertSame(f, f.fork());
1249	<	f.helpQuiesce();
1249	>	helpQuiesce();
1250		assertEquals(0, getQueuedTaskCount());
1251		assertEquals(21, f.number);
1252		checkCompletedNormally(f);
#	Line 1231 | Line 1254 | public class ForkJoinTaskTest extends JS
1254		testInvokeOnPool(singletonPool(), a);
1255		}
1256
1234	–
1257		/**
1258		* invoke task throws exception when task completes abnormally
1259		*/
1260		public void testAbnormalInvokeSingleton() {
1261		RecursiveAction a = new CheckedRecursiveAction() {
1262	<	public void realCompute() {
1262	>	protected void realCompute() {
1263		FailingAsyncFib f = new FailingAsyncFib(8);
1264		try {
1265		f.invoke();
#	Line 1254 | Line 1276 | public class ForkJoinTaskTest extends JS
1276		*/
1277		public void testAbnormalQuietlyInvokeSingleton() {
1278		RecursiveAction a = new CheckedRecursiveAction() {
1279	<	public void realCompute() {
1279	>	protected void realCompute() {
1280		FailingAsyncFib f = new FailingAsyncFib(8);
1281		f.quietlyInvoke();
1282		assertTrue(f.getException() instanceof FJException);
#	Line 1268 | Line 1290 | public class ForkJoinTaskTest extends JS
1290		*/
1291		public void testAbnormalForkJoinSingleton() {
1292		RecursiveAction a = new CheckedRecursiveAction() {
1293	<	public void realCompute() {
1293	>	protected void realCompute() {
1294		FailingAsyncFib f = new FailingAsyncFib(8);
1295		assertSame(f, f.fork());
1296		try {
#	Line 1286 | Line 1308 | public class ForkJoinTaskTest extends JS
1308		*/
1309		public void testAbnormalForkGetSingleton() {
1310		RecursiveAction a = new CheckedRecursiveAction() {
1311	<	public void realCompute() throws Exception {
1311	>	protected void realCompute() throws Exception {
1312		FailingAsyncFib f = new FailingAsyncFib(8);
1313		assertSame(f, f.fork());
1314		try {
#	Line 1306 | Line 1328 | public class ForkJoinTaskTest extends JS
1328		*/
1329		public void testAbnormalForkTimedGetSingleton() {
1330		RecursiveAction a = new CheckedRecursiveAction() {
1331	<	public void realCompute() throws Exception {
1331	>	protected void realCompute() throws Exception {
1332		FailingAsyncFib f = new FailingAsyncFib(8);
1333		assertSame(f, f.fork());
1334		try {
#	Line 1326 | Line 1348 | public class ForkJoinTaskTest extends JS
1348		*/
1349		public void testAbnormalForkQuietlyJoinSingleton() {
1350		RecursiveAction a = new CheckedRecursiveAction() {
1351	<	public void realCompute() {
1351	>	protected void realCompute() {
1352		FailingAsyncFib f = new FailingAsyncFib(8);
1353		assertSame(f, f.fork());
1354		f.quietlyJoin();
#	Line 1341 | Line 1363 | public class ForkJoinTaskTest extends JS
1363		*/
1364		public void testCancelledInvokeSingleton() {
1365		RecursiveAction a = new CheckedRecursiveAction() {
1366	<	public void realCompute() {
1366	>	protected void realCompute() {
1367		AsyncFib f = new AsyncFib(8);
1368		assertTrue(f.cancel(true));
1369		try {
#	Line 1359 | Line 1381 | public class ForkJoinTaskTest extends JS
1381		*/
1382		public void testCancelledForkJoinSingleton() {
1383		RecursiveAction a = new CheckedRecursiveAction() {
1384	<	public void realCompute() {
1384	>	protected void realCompute() {
1385		AsyncFib f = new AsyncFib(8);
1386		assertTrue(f.cancel(true));
1387		assertSame(f, f.fork());
#	Line 1378 | Line 1400 | public class ForkJoinTaskTest extends JS
1400		*/
1401		public void testCancelledForkGetSingleton() {
1402		RecursiveAction a = new CheckedRecursiveAction() {
1403	<	public void realCompute() throws Exception {
1403	>	protected void realCompute() throws Exception {
1404		AsyncFib f = new AsyncFib(8);
1405		assertTrue(f.cancel(true));
1406		assertSame(f, f.fork());
#	Line 1397 | Line 1419 | public class ForkJoinTaskTest extends JS
1419		*/
1420		public void testCancelledForkTimedGetSingleton() throws Exception {
1421		RecursiveAction a = new CheckedRecursiveAction() {
1422	<	public void realCompute() throws Exception {
1422	>	protected void realCompute() throws Exception {
1423		AsyncFib f = new AsyncFib(8);
1424		assertTrue(f.cancel(true));
1425		assertSame(f, f.fork());
#	Line 1416 | Line 1438 | public class ForkJoinTaskTest extends JS
1438		*/
1439		public void testCancelledForkQuietlyJoinSingleton() {
1440		RecursiveAction a = new CheckedRecursiveAction() {
1441	<	public void realCompute() {
1441	>	protected void realCompute() {
1442		AsyncFib f = new AsyncFib(8);
1443		assertTrue(f.cancel(true));
1444		assertSame(f, f.fork());
#	Line 1431 | Line 1453 | public class ForkJoinTaskTest extends JS
1453		*/
1454		public void testCompleteExceptionallySingleton() {
1455		RecursiveAction a = new CheckedRecursiveAction() {
1456	<	public void realCompute() {
1456	>	protected void realCompute() {
1457		AsyncFib f = new AsyncFib(8);
1458		f.completeExceptionally(new FJException());
1459		try {
#	Line 1449 | Line 1471 | public class ForkJoinTaskTest extends JS
1471		*/
1472		public void testInvokeAll2Singleton() {
1473		RecursiveAction a = new CheckedRecursiveAction() {
1474	<	public void realCompute() {
1474	>	protected void realCompute() {
1475		AsyncFib f = new AsyncFib(8);
1476		AsyncFib g = new AsyncFib(9);
1477		invokeAll(f, g);
#	Line 1466 | Line 1488 | public class ForkJoinTaskTest extends JS
1488		*/
1489		public void testInvokeAll1Singleton() {
1490		RecursiveAction a = new CheckedRecursiveAction() {
1491	<	public void realCompute() {
1491	>	protected void realCompute() {
1492		AsyncFib f = new AsyncFib(8);
1493		invokeAll(f);
1494		checkCompletedNormally(f);
#	Line 1480 | Line 1502 | public class ForkJoinTaskTest extends JS
1502		*/
1503		public void testInvokeAll3Singleton() {
1504		RecursiveAction a = new CheckedRecursiveAction() {
1505	<	public void realCompute() {
1505	>	protected void realCompute() {
1506		AsyncFib f = new AsyncFib(8);
1507		AsyncFib g = new AsyncFib(9);
1508		AsyncFib h = new AsyncFib(7);
#	Line 1500 | Line 1522 | public class ForkJoinTaskTest extends JS
1522		*/
1523		public void testInvokeAllCollectionSingleton() {
1524		RecursiveAction a = new CheckedRecursiveAction() {
1525	<	public void realCompute() {
1525	>	protected void realCompute() {
1526		AsyncFib f = new AsyncFib(8);
1527		AsyncFib g = new AsyncFib(9);
1528		AsyncFib h = new AsyncFib(7);
#	Line 1519 | Line 1541 | public class ForkJoinTaskTest extends JS
1541		testInvokeOnPool(singletonPool(), a);
1542		}
1543
1522	–
1544		/**
1545		* invokeAll(tasks) with any null task throws NPE
1546		*/
1547		public void testInvokeAllNPESingleton() {
1548		RecursiveAction a = new CheckedRecursiveAction() {
1549	<	public void realCompute() {
1549	>	protected void realCompute() {
1550		AsyncFib f = new AsyncFib(8);
1551		AsyncFib g = new AsyncFib(9);
1552		AsyncFib h = null;
#	Line 1542 | Line 1563 | public class ForkJoinTaskTest extends JS
1563		*/
1564		public void testAbnormalInvokeAll2Singleton() {
1565		RecursiveAction a = new CheckedRecursiveAction() {
1566	<	public void realCompute() {
1566	>	protected void realCompute() {
1567		AsyncFib f = new AsyncFib(8);
1568		FailingAsyncFib g = new FailingAsyncFib(9);
1569	+	ForkJoinTask[] tasks = { f, g };
1570	+	Collections.shuffle(Arrays.asList(tasks));
1571		try {
1572	<	invokeAll(f, g);
1572	>	invokeAll(tasks);
1573		shouldThrow();
1574		} catch (FJException success) {
1575		checkCompletedAbnormally(g, success);
#	Line 1560 | Line 1583 | public class ForkJoinTaskTest extends JS
1583		*/
1584		public void testAbnormalInvokeAll1Singleton() {
1585		RecursiveAction a = new CheckedRecursiveAction() {
1586	<	public void realCompute() {
1586	>	protected void realCompute() {
1587		FailingAsyncFib g = new FailingAsyncFib(9);
1588		try {
1589		invokeAll(g);
#	Line 1577 | Line 1600 | public class ForkJoinTaskTest extends JS
1600		*/
1601		public void testAbnormalInvokeAll3Singleton() {
1602		RecursiveAction a = new CheckedRecursiveAction() {
1603	<	public void realCompute() {
1603	>	protected void realCompute() {
1604		AsyncFib f = new AsyncFib(8);
1605		FailingAsyncFib g = new FailingAsyncFib(9);
1606		AsyncFib h = new AsyncFib(7);
1607	+	ForkJoinTask[] tasks = { f, g, h };
1608	+	Collections.shuffle(Arrays.asList(tasks));
1609		try {
1610	<	invokeAll(f, g, h);
1610	>	invokeAll(tasks);
1611		shouldThrow();
1612		} catch (FJException success) {
1613		checkCompletedAbnormally(g, success);
#	Line 1592 | Line 1617 | public class ForkJoinTaskTest extends JS
1617		}
1618
1619		/**
1620	<	* invokeAll(collection)  throws exception if any task does
1620	>	* invokeAll(collection) throws exception if any task does
1621		*/
1622		public void testAbnormalInvokeAllCollectionSingleton() {
1623		RecursiveAction a = new CheckedRecursiveAction() {
1624	<	public void realCompute() {
1624	>	protected void realCompute() {
1625		FailingAsyncFib f = new FailingAsyncFib(8);
1626		AsyncFib g = new AsyncFib(9);
1627		AsyncFib h = new AsyncFib(7);
1628	<	HashSet set = new HashSet();
1629	<	set.add(f);
1630	<	set.add(g);
1606	<	set.add(h);
1628	>	ForkJoinTask[] tasks = { f, g, h };
1629	>	List taskList = Arrays.asList(tasks);
1630	>	Collections.shuffle(taskList);
1631		try {
1632	<	invokeAll(set);
1632	>	invokeAll(taskList);
1633		shouldThrow();
1634		} catch (FJException success) {
1635		checkCompletedAbnormally(f, success);
#	Line 1614 | Line 1638 | public class ForkJoinTaskTest extends JS
1638		testInvokeOnPool(singletonPool(), a);
1639		}
1640
1641	+	/**
1642	+	* ForkJoinTask.quietlyComplete returns when task completes
1643	+	* normally without setting a value. The most recent value
1644	+	* established by setRawResult(V) (or null by default) is returned
1645	+	* from invoke.
1646	+	*/
1647	+	public void testQuietlyComplete() {
1648	+	RecursiveAction a = new CheckedRecursiveAction() {
1649	+	protected void realCompute() {
1650	+	AsyncFib f = new AsyncFib(8);
1651	+	f.quietlyComplete();
1652	+	assertEquals(8, f.number);
1653	+	checkCompletedNormally(f);
1654	+	}};
1655	+	testInvokeOnPool(mainPool(), a);
1656	+	}
1657	+
1658		}

Diff Legend

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