ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ForkJoinTask8Test.java

Comparing jsr166/src/test/tck/ForkJoinTask8Test.java (file contents):
Revision 1.8 by jsr166, Thu Jan 15 18:34:19 2015 UTC vs.
Revision 1.15 by dl, Tue Sep 8 23:56:19 2015 UTC

#	Line 7 | Line 7
7		import static java.util.concurrent.TimeUnit.MILLISECONDS;
8		import static java.util.concurrent.TimeUnit.SECONDS;
9
10	<	import java.util.HashSet;
10	>	import java.util.Arrays;
11	>	import java.util.Collections;
12	>	import java.util.concurrent.CountDownLatch;
13		import java.util.concurrent.ExecutionException;
14		import java.util.concurrent.ForkJoinPool;
15		import java.util.concurrent.ForkJoinTask;
16	+	import java.util.concurrent.ForkJoinWorkerThread;
17		import java.util.concurrent.RecursiveAction;
18		import java.util.concurrent.TimeoutException;
19
#	Line 34 | Line 37 | public class ForkJoinTask8Test extends J
37		static final short EXCEPTION_STATE = 1;
38
39		public static void main(String[] args) {
40	<	junit.textui.TestRunner.run(suite());
40	>	main(suite(), args);
41		}
42
43		public static Test suite() {
#	Line 59 | Line 62 | public class ForkJoinTask8Test extends J
62		null, true);
63		}
64
65	+	// Compute fib naively and efficiently
66	+	final int[] fib;
67	+	{
68	+	int[] fib = new int[10];
69	+	fib[0] = 0;
70	+	fib[1] = 1;
71	+	for (int i = 2; i < fib.length; i++)
72	+	fib[i] = fib[i - 1] + fib[i - 2];
73	+	this.fib = fib;
74	+	}
75	+
76		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
77		try {
78		assertFalse(a.isDone());
#	Line 279 | Line 293 | public class ForkJoinTask8Test extends J
293
294		}
295
296	<	static final class AsyncFib extends BinaryAsyncAction {
296	>	final class AsyncFib extends BinaryAsyncAction {
297		int number;
298	<	public AsyncFib(int n) {
299	<	this.number = n;
298	>	int expectedResult;
299	>	public AsyncFib(int number) {
300	>	this.number = number;
301	>	this.expectedResult = fib[number];
302		}
303
304		public final boolean exec() {
#	Line 311 | Line 327 | public class ForkJoinTask8Test extends J
327		number = ((AsyncFib)x).number + ((AsyncFib)y).number;
328		super.onComplete(x, y);
329		}
330	+
331	+	public void checkCompletedNormally() {
332	+	assertEquals(expectedResult, number);
333	+	ForkJoinTask8Test.this.checkCompletedNormally(this);
334	+	}
335		}
336
337		static final class FailingAsyncFib extends BinaryAsyncAction {
#	Line 347 | Line 368 | public class ForkJoinTask8Test extends J
368		* completed tasks; getRawResult returns null.
369		*/
370		public void testInvoke() {
371	+	testInvoke(mainPool());
372	+	}
373	+	public void testInvoke_Singleton() {
374	+	testInvoke(singletonPool());
375	+	}
376	+	public void testInvoke(ForkJoinPool pool) {
377		RecursiveAction a = new CheckedRecursiveAction() {
378		protected void realCompute() {
379		AsyncFib f = new AsyncFib(8);
380		assertNull(f.invoke());
381	<	assertEquals(21, f.number);
355	<	checkCompletedNormally(f);
381	>	f.checkCompletedNormally();
382		}};
383	<	testInvokeOnPool(mainPool(), a);
383	>	testInvokeOnPool(pool, a);
384		}
385
386		/**
#	Line 363 | Line 389 | public class ForkJoinTask8Test extends J
389		* completed tasks
390		*/
391		public void testQuietlyInvoke() {
392	+	testQuietlyInvoke(mainPool());
393	+	}
394	+	public void testQuietlyInvoke_Singleton() {
395	+	testQuietlyInvoke(singletonPool());
396	+	}
397	+	public void testQuietlyInvoke(ForkJoinPool pool) {
398		RecursiveAction a = new CheckedRecursiveAction() {
399		protected void realCompute() {
400		AsyncFib f = new AsyncFib(8);
401		f.quietlyInvoke();
402	<	assertEquals(21, f.number);
371	<	checkCompletedNormally(f);
402	>	f.checkCompletedNormally();
403		}};
404	<	testInvokeOnPool(mainPool(), a);
404	>	testInvokeOnPool(pool, a);
405		}
406
407		/**
408		* join of a forked task returns when task completes
409		*/
410		public void testForkJoin() {
411	+	testForkJoin(mainPool());
412	+	}
413	+	public void testForkJoin_Singleton() {
414	+	testForkJoin(singletonPool());
415	+	}
416	+	public void testForkJoin(ForkJoinPool pool) {
417		RecursiveAction a = new CheckedRecursiveAction() {
418		protected void realCompute() {
419		AsyncFib f = new AsyncFib(8);
420		assertSame(f, f.fork());
421		assertNull(f.join());
422	<	assertEquals(21, f.number);
386	<	checkCompletedNormally(f);
422	>	f.checkCompletedNormally();
423		}};
424	<	testInvokeOnPool(mainPool(), a);
424	>	testInvokeOnPool(pool, a);
425		}
426
427		/**
428		* get of a forked task returns when task completes
429		*/
430		public void testForkGet() {
431	+	testForkGet(mainPool());
432	+	}
433	+	public void testForkGet_Singleton() {
434	+	testForkGet(singletonPool());
435	+	}
436	+	public void testForkGet(ForkJoinPool pool) {
437		RecursiveAction a = new CheckedRecursiveAction() {
438		protected void realCompute() throws Exception {
439		AsyncFib f = new AsyncFib(8);
440		assertSame(f, f.fork());
441		assertNull(f.get());
442	<	assertEquals(21, f.number);
401	<	checkCompletedNormally(f);
442	>	f.checkCompletedNormally();
443		}};
444	<	testInvokeOnPool(mainPool(), a);
444	>	testInvokeOnPool(pool, a);
445		}
446
447		/**
448		* timed get of a forked task returns when task completes
449		*/
450		public void testForkTimedGet() {
451	+	testForkTimedGet(mainPool());
452	+	}
453	+	public void testForkTimedGet_Singleton() {
454	+	testForkTimedGet(singletonPool());
455	+	}
456	+	public void testForkTimedGet(ForkJoinPool pool) {
457		RecursiveAction a = new CheckedRecursiveAction() {
458		protected void realCompute() throws Exception {
459		AsyncFib f = new AsyncFib(8);
460		assertSame(f, f.fork());
461		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
462	<	assertEquals(21, f.number);
416	<	checkCompletedNormally(f);
462	>	f.checkCompletedNormally();
463		}};
464	<	testInvokeOnPool(mainPool(), a);
464	>	testInvokeOnPool(pool, a);
465		}
466
467		/**
468	<	* timed get with null time unit throws NPE
468	>	* timed get with null time unit throws NullPointerException
469		*/
470	<	public void testForkTimedGetNPE() {
470	>	public void testForkTimedGetNullTimeUnit() {
471	>	testForkTimedGetNullTimeUnit(mainPool());
472	>	}
473	>	public void testForkTimedGetNullTimeUnit_Singleton() {
474	>	testForkTimedGet(singletonPool());
475	>	}
476	>	public void testForkTimedGetNullTimeUnit(ForkJoinPool pool) {
477		RecursiveAction a = new CheckedRecursiveAction() {
478		protected void realCompute() throws Exception {
479		AsyncFib f = new AsyncFib(8);
#	Line 431 | Line 483 | public class ForkJoinTask8Test extends J
483		shouldThrow();
484		} catch (NullPointerException success) {}
485		}};
486	<	testInvokeOnPool(mainPool(), a);
486	>	testInvokeOnPool(pool, a);
487		}
488
489		/**
490		* quietlyJoin of a forked task returns when task completes
491		*/
492		public void testForkQuietlyJoin() {
493	+	testForkQuietlyJoin(mainPool());
494	+	}
495	+	public void testForkQuietlyJoin_Singleton() {
496	+	testForkQuietlyJoin(singletonPool());
497	+	}
498	+	public void testForkQuietlyJoin(ForkJoinPool pool) {
499		RecursiveAction a = new CheckedRecursiveAction() {
500		protected void realCompute() {
501		AsyncFib f = new AsyncFib(8);
502		assertSame(f, f.fork());
503		f.quietlyJoin();
504	<	assertEquals(21, f.number);
447	<	checkCompletedNormally(f);
504	>	f.checkCompletedNormally();
505		}};
506	<	testInvokeOnPool(mainPool(), a);
506	>	testInvokeOnPool(pool, a);
507		}
508
509		/**
#	Line 454 | Line 511 | public class ForkJoinTask8Test extends J
511		* getQueuedTaskCount returns 0 when quiescent
512		*/
513		public void testForkHelpQuiesce() {
514	+	testForkHelpQuiesce(mainPool());
515	+	}
516	+	public void testForkHelpQuiesce_Singleton() {
517	+	testForkHelpQuiesce(singletonPool());
518	+	}
519	+	public void testForkHelpQuiesce(ForkJoinPool pool) {
520		RecursiveAction a = new CheckedRecursiveAction() {
521		protected void realCompute() {
522		AsyncFib f = new AsyncFib(8);
523		assertSame(f, f.fork());
524		helpQuiesce();
462	–	assertEquals(21, f.number);
525		assertEquals(0, getQueuedTaskCount());
526	<	checkCompletedNormally(f);
526	>	f.checkCompletedNormally();
527		}};
528	<	testInvokeOnPool(mainPool(), a);
528	>	testInvokeOnPool(pool, a);
529		}
530
531		/**
532		* invoke task throws exception when task completes abnormally
533		*/
534		public void testAbnormalInvoke() {
535	+	testAbnormalInvoke(mainPool());
536	+	}
537	+	public void testAbnormalInvoke_Singleton() {
538	+	testAbnormalInvoke(singletonPool());
539	+	}
540	+	public void testAbnormalInvoke(ForkJoinPool pool) {
541		RecursiveAction a = new CheckedRecursiveAction() {
542		protected void realCompute() {
543		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 480 | Line 548 | public class ForkJoinTask8Test extends J
548		checkCompletedAbnormally(f, success);
549		}
550		}};
551	<	testInvokeOnPool(mainPool(), a);
551	>	testInvokeOnPool(pool, a);
552		}
553
554		/**
555		* quietlyInvoke task returns when task completes abnormally
556		*/
557		public void testAbnormalQuietlyInvoke() {
558	+	testAbnormalQuietlyInvoke(mainPool());
559	+	}
560	+	public void testAbnormalQuietlyInvoke_Singleton() {
561	+	testAbnormalQuietlyInvoke(singletonPool());
562	+	}
563	+	public void testAbnormalQuietlyInvoke(ForkJoinPool pool) {
564		RecursiveAction a = new CheckedRecursiveAction() {
565		protected void realCompute() {
566		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 494 | Line 568 | public class ForkJoinTask8Test extends J
568		assertTrue(f.getException() instanceof FJException);
569		checkCompletedAbnormally(f, f.getException());
570		}};
571	<	testInvokeOnPool(mainPool(), a);
571	>	testInvokeOnPool(pool, a);
572		}
573
574		/**
575		* join of a forked task throws exception when task completes abnormally
576		*/
577		public void testAbnormalForkJoin() {
578	+	testAbnormalForkJoin(mainPool());
579	+	}
580	+	public void testAbnormalForkJoin_Singleton() {
581	+	testAbnormalForkJoin(singletonPool());
582	+	}
583	+	public void testAbnormalForkJoin(ForkJoinPool pool) {
584		RecursiveAction a = new CheckedRecursiveAction() {
585		protected void realCompute() {
586		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 512 | Line 592 | public class ForkJoinTask8Test extends J
592		checkCompletedAbnormally(f, success);
593		}
594		}};
595	<	testInvokeOnPool(mainPool(), a);
595	>	testInvokeOnPool(pool, a);
596		}
597
598		/**
599		* get of a forked task throws exception when task completes abnormally
600		*/
601		public void testAbnormalForkGet() {
602	+	testAbnormalForkGet(mainPool());
603	+	}
604	+	public void testAbnormalForkGet_Singleton() {
605	+	testAbnormalForkJoin(singletonPool());
606	+	}
607	+	public void testAbnormalForkGet(ForkJoinPool pool) {
608		RecursiveAction a = new CheckedRecursiveAction() {
609		protected void realCompute() throws Exception {
610		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 532 | Line 618 | public class ForkJoinTask8Test extends J
618		checkCompletedAbnormally(f, cause);
619		}
620		}};
621	<	testInvokeOnPool(mainPool(), a);
621	>	testInvokeOnPool(pool, a);
622		}
623
624		/**
625		* timed get of a forked task throws exception when task completes abnormally
626		*/
627		public void testAbnormalForkTimedGet() {
628	+	testAbnormalForkTimedGet(mainPool());
629	+	}
630	+	public void testAbnormalForkTimedGet_Singleton() {
631	+	testAbnormalForkTimedGet(singletonPool());
632	+	}
633	+	public void testAbnormalForkTimedGet(ForkJoinPool pool) {
634		RecursiveAction a = new CheckedRecursiveAction() {
635		protected void realCompute() throws Exception {
636		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 552 | Line 644 | public class ForkJoinTask8Test extends J
644		checkCompletedAbnormally(f, cause);
645		}
646		}};
647	<	testInvokeOnPool(mainPool(), a);
647	>	testInvokeOnPool(pool, a);
648		}
649
650		/**
651		* quietlyJoin of a forked task returns when task completes abnormally
652		*/
653		public void testAbnormalForkQuietlyJoin() {
654	+	testAbnormalForkQuietlyJoin(mainPool());
655	+	}
656	+	public void testAbnormalForkQuietlyJoin_Singleton() {
657	+	testAbnormalForkQuietlyJoin(singletonPool());
658	+	}
659	+	public void testAbnormalForkQuietlyJoin(ForkJoinPool pool) {
660		RecursiveAction a = new CheckedRecursiveAction() {
661		protected void realCompute() {
662		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 567 | Line 665 | public class ForkJoinTask8Test extends J
665		assertTrue(f.getException() instanceof FJException);
666		checkCompletedAbnormally(f, f.getException());
667		}};
668	<	testInvokeOnPool(mainPool(), a);
668	>	testInvokeOnPool(pool, a);
669		}
670
671		/**
672		* getPool of executing task returns its pool
673		*/
674		public void testGetPool() {
675	<	final ForkJoinPool mainPool = mainPool();
675	>	testGetPool(mainPool());
676	>	}
677	>	public void testGetPool_Singleton() {
678	>	testGetPool(singletonPool());
679	>	}
680	>	public void testGetPool(ForkJoinPool pool) {
681		RecursiveAction a = new CheckedRecursiveAction() {
682		protected void realCompute() {
683	<	assertSame(mainPool, getPool());
683	>	assertSame(pool, getPool());
684		}};
685	<	testInvokeOnPool(mainPool, a);
685	>	testInvokeOnPool(pool, a);
686		}
687
688		/**
#	Line 597 | Line 700 | public class ForkJoinTask8Test extends J
700		* inForkJoinPool of executing task returns true
701		*/
702		public void testInForkJoinPool() {
703	+	testInForkJoinPool(mainPool());
704	+	}
705	+	public void testInForkJoinPool_Singleton() {
706	+	testInForkJoinPool(singletonPool());
707	+	}
708	+	public void testInForkJoinPool(ForkJoinPool pool) {
709		RecursiveAction a = new CheckedRecursiveAction() {
710		protected void realCompute() {
711		assertTrue(inForkJoinPool());
712		}};
713	<	testInvokeOnPool(mainPool(), a);
713	>	testInvokeOnPool(pool, a);
714		}
715
716		/**
#	Line 631 | Line 740 | public class ForkJoinTask8Test extends J
740		* invoke task throws exception after invoking completeExceptionally
741		*/
742		public void testCompleteExceptionally() {
743	+	testCompleteExceptionally(mainPool());
744	+	}
745	+	public void testCompleteExceptionally_Singleton() {
746	+	testCompleteExceptionally(singletonPool());
747	+	}
748	+	public void testCompleteExceptionally(ForkJoinPool pool) {
749		RecursiveAction a = new CheckedRecursiveAction() {
750		protected void realCompute() {
751		AsyncFib f = new AsyncFib(8);
#	Line 642 | Line 757 | public class ForkJoinTask8Test extends J
757		checkCompletedAbnormally(f, success);
758		}
759		}};
760	<	testInvokeOnPool(mainPool(), a);
760	>	testInvokeOnPool(pool, a);
761		}
762
763		/**
764	<	* invokeAll(t1, t2) invokes all task arguments
764	>	* invokeAll(tasks) with 1 argument invokes task
765		*/
766	<	public void testInvokeAll2() {
766	>	public void testInvokeAll1() {
767	>	testInvokeAll1(mainPool());
768	>	}
769	>	public void testInvokeAll1_Singleton() {
770	>	testInvokeAll1(singletonPool());
771	>	}
772	>	public void testInvokeAll1(ForkJoinPool pool) {
773		RecursiveAction a = new CheckedRecursiveAction() {
774		protected void realCompute() {
775		AsyncFib f = new AsyncFib(8);
776	<	AsyncFib g = new AsyncFib(9);
777	<	invokeAll(f, g);
657	<	assertEquals(21, f.number);
658	<	assertEquals(34, g.number);
659	<	checkCompletedNormally(f);
660	<	checkCompletedNormally(g);
776	>	invokeAll(f);
777	>	f.checkCompletedNormally();
778		}};
779	<	testInvokeOnPool(mainPool(), a);
779	>	testInvokeOnPool(pool, a);
780		}
781
782		/**
783	<	* invokeAll(tasks) with 1 argument invokes task
783	>	* invokeAll(t1, t2) invokes all task arguments
784		*/
785	<	public void testInvokeAll1() {
785	>	public void testInvokeAll2() {
786	>	testInvokeAll2(mainPool());
787	>	}
788	>	public void testInvokeAll2_Singleton() {
789	>	testInvokeAll2(singletonPool());
790	>	}
791	>	public void testInvokeAll2(ForkJoinPool pool) {
792		RecursiveAction a = new CheckedRecursiveAction() {
793		protected void realCompute() {
794	<	AsyncFib f = new AsyncFib(8);
795	<	invokeAll(f);
796	<	checkCompletedNormally(f);
797	<	assertEquals(21, f.number);
794	>	AsyncFib[] tasks = {
795	>	new AsyncFib(8),
796	>	new AsyncFib(9),
797	>	};
798	>	invokeAll(tasks[0], tasks[1]);
799	>	for (AsyncFib task : tasks) assertTrue(task.isDone());
800	>	for (AsyncFib task : tasks) task.checkCompletedNormally();
801		}};
802	<	testInvokeOnPool(mainPool(), a);
802	>	testInvokeOnPool(pool, a);
803		}
804
805		/**
806		* invokeAll(tasks) with > 2 argument invokes tasks
807		*/
808		public void testInvokeAll3() {
809	+	testInvokeAll3(mainPool());
810	+	}
811	+	public void testInvokeAll3_Singleton() {
812	+	testInvokeAll3(singletonPool());
813	+	}
814	+	public void testInvokeAll3(ForkJoinPool pool) {
815		RecursiveAction a = new CheckedRecursiveAction() {
816		protected void realCompute() {
817	<	AsyncFib f = new AsyncFib(8);
818	<	AsyncFib g = new AsyncFib(9);
819	<	AsyncFib h = new AsyncFib(7);
820	<	invokeAll(f, g, h);
821	<	assertEquals(21, f.number);
822	<	assertEquals(34, g.number);
823	<	assertEquals(13, h.number);
824	<	checkCompletedNormally(f);
693	<	checkCompletedNormally(g);
694	<	checkCompletedNormally(h);
817	>	AsyncFib[] tasks = {
818	>	new AsyncFib(8),
819	>	new AsyncFib(9),
820	>	new AsyncFib(7),
821	>	};
822	>	invokeAll(tasks[0], tasks[1], tasks[2]);
823	>	for (AsyncFib task : tasks) assertTrue(task.isDone());
824	>	for (AsyncFib task : tasks) task.checkCompletedNormally();
825		}};
826	<	testInvokeOnPool(mainPool(), a);
826	>	testInvokeOnPool(pool, a);
827		}
828
829		/**
830		* invokeAll(collection) invokes all tasks in the collection
831		*/
832		public void testInvokeAllCollection() {
833	+	testInvokeAllCollection(mainPool());
834	+	}
835	+	public void testInvokeAllCollection_Singleton() {
836	+	testInvokeAllCollection(singletonPool());
837	+	}
838	+	public void testInvokeAllCollection(ForkJoinPool pool) {
839		RecursiveAction a = new CheckedRecursiveAction() {
840		protected void realCompute() {
841	<	AsyncFib f = new AsyncFib(8);
842	<	AsyncFib g = new AsyncFib(9);
843	<	AsyncFib h = new AsyncFib(7);
844	<	HashSet set = new HashSet();
845	<	set.add(f);
846	<	set.add(g);
847	<	set.add(h);
848	<	invokeAll(set);
713	<	assertEquals(21, f.number);
714	<	assertEquals(34, g.number);
715	<	assertEquals(13, h.number);
716	<	checkCompletedNormally(f);
717	<	checkCompletedNormally(g);
718	<	checkCompletedNormally(h);
841	>	AsyncFib[] tasks = {
842	>	new AsyncFib(8),
843	>	new AsyncFib(9),
844	>	new AsyncFib(7),
845	>	};
846	>	invokeAll(Arrays.asList(tasks));
847	>	for (AsyncFib task : tasks) assertTrue(task.isDone());
848	>	for (AsyncFib task : tasks) task.checkCompletedNormally();
849		}};
850	<	testInvokeOnPool(mainPool(), a);
850	>	testInvokeOnPool(pool, a);
851		}
852
853		/**
854	<	* invokeAll(tasks) with any null task throws NPE
854	>	* invokeAll(tasks) with any null task throws NullPointerException
855		*/
856	<	public void testInvokeAllNPE() {
856	>	public void testInvokeAllNullTask() {
857	>	testInvokeAllNullTask(mainPool());
858	>	}
859	>	public void testInvokeAllNullTask_Singleton() {
860	>	testInvokeAllNullTask(singletonPool());
861	>	}
862	>	public void testInvokeAllNullTask(ForkJoinPool pool) {
863		RecursiveAction a = new CheckedRecursiveAction() {
864		protected void realCompute() {
865	<	AsyncFib f = new AsyncFib(8);
866	<	AsyncFib g = new AsyncFib(9);
867	<	AsyncFib h = null;
868	<	try {
869	<	invokeAll(f, g, h);
870	<	shouldThrow();
871	<	} catch (NullPointerException success) {}
865	>	AsyncFib nul = null;
866	>	Runnable[] throwingActions = {
867	>	() -> invokeAll(nul),
868	>	() -> invokeAll(nul, nul),
869	>	() -> invokeAll(new AsyncFib(8), new AsyncFib(9), nul),
870	>	() -> invokeAll(new AsyncFib(8), nul, new AsyncFib(9)),
871	>	() -> invokeAll(nul, new AsyncFib(8), new AsyncFib(9)),
872	>	};
873	>	assertThrows(NullPointerException.class, throwingActions);
874		}};
875	<	testInvokeOnPool(mainPool(), a);
875	>	testInvokeOnPool(pool, a);
876		}
877
878		/**
879	<	* invokeAll(t1, t2) throw exception if any task does
879	>	* invokeAll(tasks) with 1 argument throws exception if task does
880		*/
881	<	public void testAbnormalInvokeAll2() {
881	>	public void testAbnormalInvokeAll1() {
882	>	testAbnormalInvokeAll1(mainPool());
883	>	}
884	>	public void testAbnormalInvokeAll1_Singleton() {
885	>	testAbnormalInvokeAll1(singletonPool());
886	>	}
887	>	public void testAbnormalInvokeAll1(ForkJoinPool pool) {
888		RecursiveAction a = new CheckedRecursiveAction() {
889		protected void realCompute() {
746	–	AsyncFib f = new AsyncFib(8);
890		FailingAsyncFib g = new FailingAsyncFib(9);
891		try {
892	<	invokeAll(f, g);
892	>	invokeAll(g);
893		shouldThrow();
894		} catch (FJException success) {
895		checkCompletedAbnormally(g, success);
896		}
897		}};
898	<	testInvokeOnPool(mainPool(), a);
898	>	testInvokeOnPool(pool, a);
899		}
900
901		/**
902	<	* invokeAll(tasks) with 1 argument throws exception if task does
902	>	* invokeAll(t1, t2) throw exception if any task does
903		*/
904	<	public void testAbnormalInvokeAll1() {
904	>	public void testAbnormalInvokeAll2() {
905	>	testAbnormalInvokeAll2(mainPool());
906	>	}
907	>	public void testAbnormalInvokeAll2_Singleton() {
908	>	testAbnormalInvokeAll2(singletonPool());
909	>	}
910	>	public void testAbnormalInvokeAll2(ForkJoinPool pool) {
911		RecursiveAction a = new CheckedRecursiveAction() {
912		protected void realCompute() {
913	+	AsyncFib f = new AsyncFib(8);
914		FailingAsyncFib g = new FailingAsyncFib(9);
915	+	ForkJoinTask[] tasks = { f, g };
916	+	Collections.shuffle(Arrays.asList(tasks));
917		try {
918	<	invokeAll(g);
918	>	invokeAll(tasks[0], tasks[1]);
919		shouldThrow();
920		} catch (FJException success) {
921		checkCompletedAbnormally(g, success);
922		}
923		}};
924	<	testInvokeOnPool(mainPool(), a);
924	>	testInvokeOnPool(pool, a);
925		}
926
927		/**
928		* invokeAll(tasks) with > 2 argument throws exception if any task does
929		*/
930		public void testAbnormalInvokeAll3() {
931	+	testAbnormalInvokeAll3(mainPool());
932	+	}
933	+	public void testAbnormalInvokeAll3_Singleton() {
934	+	testAbnormalInvokeAll3(singletonPool());
935	+	}
936	+	public void testAbnormalInvokeAll3(ForkJoinPool pool) {
937		RecursiveAction a = new CheckedRecursiveAction() {
938		protected void realCompute() {
939		AsyncFib f = new AsyncFib(8);
940		FailingAsyncFib g = new FailingAsyncFib(9);
941		AsyncFib h = new AsyncFib(7);
942	+	ForkJoinTask[] tasks = { f, g, h };
943	+	Collections.shuffle(Arrays.asList(tasks));
944		try {
945	<	invokeAll(f, g, h);
945	>	invokeAll(tasks[0], tasks[1], tasks[2]);
946		shouldThrow();
947		} catch (FJException success) {
948		checkCompletedAbnormally(g, success);
949		}
950		}};
951	<	testInvokeOnPool(mainPool(), a);
951	>	testInvokeOnPool(pool, a);
952		}
953
954		/**
955		* invokeAll(collection) throws exception if any task does
956		*/
957		public void testAbnormalInvokeAllCollection() {
958	+	testAbnormalInvokeAllCollection(mainPool());
959	+	}
960	+	public void testAbnormalInvokeAllCollection_Singleton() {
961	+	testAbnormalInvokeAllCollection(singletonPool());
962	+	}
963	+	public void testAbnormalInvokeAllCollection(ForkJoinPool pool) {
964		RecursiveAction a = new CheckedRecursiveAction() {
965		protected void realCompute() {
966		FailingAsyncFib f = new FailingAsyncFib(8);
967		AsyncFib g = new AsyncFib(9);
968		AsyncFib h = new AsyncFib(7);
969	<	HashSet set = new HashSet();
970	<	set.add(f);
805	<	set.add(g);
806	<	set.add(h);
969	>	ForkJoinTask[] tasks = { f, g, h };
970	>	Collections.shuffle(Arrays.asList(tasks));
971		try {
972	<	invokeAll(set);
972	>	invokeAll(Arrays.asList(tasks));
973		shouldThrow();
974		} catch (FJException success) {
975		checkCompletedAbnormally(f, success);
976		}
977		}};
978	<	testInvokeOnPool(mainPool(), a);
978	>	testInvokeOnPool(pool, a);
979		}
980
981		/**
#	Line 828 | Line 992 | public class ForkJoinTask8Test extends J
992		assertTrue(f.tryUnfork());
993		helpQuiesce();
994		checkNotDone(f);
995	<	checkCompletedNormally(g);
995	>	g.checkCompletedNormally();
996		}};
997		testInvokeOnPool(singletonPool(), a);
998		}
#	Line 849 | Line 1013 | public class ForkJoinTask8Test extends J
1013		assertTrue(getSurplusQueuedTaskCount() > 0);
1014		helpQuiesce();
1015		assertEquals(0, getSurplusQueuedTaskCount());
1016	<	checkCompletedNormally(f);
1017	<	checkCompletedNormally(g);
1018	<	checkCompletedNormally(h);
1016	>	f.checkCompletedNormally();
1017	>	g.checkCompletedNormally();
1018	>	h.checkCompletedNormally();
1019		}};
1020		testInvokeOnPool(singletonPool(), a);
1021		}
#	Line 868 | Line 1032 | public class ForkJoinTask8Test extends J
1032		assertSame(f, f.fork());
1033		assertSame(f, peekNextLocalTask());
1034		assertNull(f.join());
1035	<	checkCompletedNormally(f);
1035	>	f.checkCompletedNormally();
1036		helpQuiesce();
1037	<	checkCompletedNormally(g);
1037	>	g.checkCompletedNormally();
1038		}};
1039		testInvokeOnPool(singletonPool(), a);
1040		}
#	Line 889 | Line 1053 | public class ForkJoinTask8Test extends J
1053		assertSame(f, pollNextLocalTask());
1054		helpQuiesce();
1055		checkNotDone(f);
1056	<	assertEquals(34, g.number);
893	<	checkCompletedNormally(g);
1056	>	g.checkCompletedNormally();
1057		}};
1058		testInvokeOnPool(singletonPool(), a);
1059		}
#	Line 908 | Line 1071 | public class ForkJoinTask8Test extends J
1071		assertSame(f, pollTask());
1072		helpQuiesce();
1073		checkNotDone(f);
1074	<	checkCompletedNormally(g);
1074	>	g.checkCompletedNormally();
1075		}};
1076		testInvokeOnPool(singletonPool(), a);
1077		}
#	Line 926 | Line 1089 | public class ForkJoinTask8Test extends J
1089		assertSame(g, peekNextLocalTask());
1090		assertNull(f.join());
1091		helpQuiesce();
1092	<	checkCompletedNormally(f);
1093	<	assertEquals(34, g.number);
931	<	checkCompletedNormally(g);
1092	>	f.checkCompletedNormally();
1093	>	g.checkCompletedNormally();
1094		}};
1095		testInvokeOnPool(asyncSingletonPool(), a);
1096		}
#	Line 946 | Line 1108 | public class ForkJoinTask8Test extends J
1108		assertSame(f, f.fork());
1109		assertSame(g, pollNextLocalTask());
1110		helpQuiesce();
1111	<	assertEquals(21, f.number);
950	<	checkCompletedNormally(f);
1111	>	f.checkCompletedNormally();
1112		checkNotDone(g);
1113		}};
1114		testInvokeOnPool(asyncSingletonPool(), a);
#	Line 966 | Line 1127 | public class ForkJoinTask8Test extends J
1127		assertSame(f, f.fork());
1128		assertSame(g, pollTask());
1129		helpQuiesce();
1130	<	assertEquals(21, f.number);
970	<	checkCompletedNormally(f);
1130	>	f.checkCompletedNormally();
1131		checkNotDone(g);
1132		}};
1133		testInvokeOnPool(asyncSingletonPool(), a);
1134		}
1135
976	–	// versions for singleton pools
977	–
978	–	/**
979	–	* invoke returns when task completes normally.
980	–	* isCompletedAbnormally and isCancelled return false for normally
981	–	* completed tasks; getRawResult returns null.
982	–	*/
983	–	public void testInvokeSingleton() {
984	–	RecursiveAction a = new CheckedRecursiveAction() {
985	–	protected void realCompute() {
986	–	AsyncFib f = new AsyncFib(8);
987	–	assertNull(f.invoke());
988	–	assertEquals(21, f.number);
989	–	checkCompletedNormally(f);
990	–	}};
991	–	testInvokeOnPool(singletonPool(), a);
992	–	}
993	–
994	–	/**
995	–	* quietlyInvoke task returns when task completes normally.
996	–	* isCompletedAbnormally and isCancelled return false for normally
997	–	* completed tasks
998	–	*/
999	–	public void testQuietlyInvokeSingleton() {
1000	–	RecursiveAction a = new CheckedRecursiveAction() {
1001	–	protected void realCompute() {
1002	–	AsyncFib f = new AsyncFib(8);
1003	–	f.quietlyInvoke();
1004	–	assertEquals(21, f.number);
1005	–	checkCompletedNormally(f);
1006	–	}};
1007	–	testInvokeOnPool(singletonPool(), a);
1008	–	}
1009	–
1010	–	/**
1011	–	* join of a forked task returns when task completes
1012	–	*/
1013	–	public void testForkJoinSingleton() {
1014	–	RecursiveAction a = new CheckedRecursiveAction() {
1015	–	protected void realCompute() {
1016	–	AsyncFib f = new AsyncFib(8);
1017	–	assertSame(f, f.fork());
1018	–	assertNull(f.join());
1019	–	assertEquals(21, f.number);
1020	–	checkCompletedNormally(f);
1021	–	}};
1022	–	testInvokeOnPool(singletonPool(), a);
1023	–	}
1024	–
1025	–	/**
1026	–	* get of a forked task returns when task completes
1027	–	*/
1028	–	public void testForkGetSingleton() {
1029	–	RecursiveAction a = new CheckedRecursiveAction() {
1030	–	protected void realCompute() throws Exception {
1031	–	AsyncFib f = new AsyncFib(8);
1032	–	assertSame(f, f.fork());
1033	–	assertNull(f.get());
1034	–	assertEquals(21, f.number);
1035	–	checkCompletedNormally(f);
1036	–	}};
1037	–	testInvokeOnPool(singletonPool(), a);
1038	–	}
1039	–
1040	–	/**
1041	–	* timed get of a forked task returns when task completes
1042	–	*/
1043	–	public void testForkTimedGetSingleton() {
1044	–	RecursiveAction a = new CheckedRecursiveAction() {
1045	–	protected void realCompute() throws Exception {
1046	–	AsyncFib f = new AsyncFib(8);
1047	–	assertSame(f, f.fork());
1048	–	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
1049	–	assertEquals(21, f.number);
1050	–	checkCompletedNormally(f);
1051	–	}};
1052	–	testInvokeOnPool(singletonPool(), a);
1053	–	}
1054	–
1055	–	/**
1056	–	* timed get with null time unit throws NPE
1057	–	*/
1058	–	public void testForkTimedGetNPESingleton() {
1059	–	RecursiveAction a = new CheckedRecursiveAction() {
1060	–	protected void realCompute() throws Exception {
1061	–	AsyncFib f = new AsyncFib(8);
1062	–	assertSame(f, f.fork());
1063	–	try {
1064	–	f.get(5L, null);
1065	–	shouldThrow();
1066	–	} catch (NullPointerException success) {}
1067	–	}};
1068	–	testInvokeOnPool(singletonPool(), a);
1069	–	}
1070	–
1071	–	/**
1072	–	* quietlyJoin of a forked task returns when task completes
1073	–	*/
1074	–	public void testForkQuietlyJoinSingleton() {
1075	–	RecursiveAction a = new CheckedRecursiveAction() {
1076	–	protected void realCompute() {
1077	–	AsyncFib f = new AsyncFib(8);
1078	–	assertSame(f, f.fork());
1079	–	f.quietlyJoin();
1080	–	assertEquals(21, f.number);
1081	–	checkCompletedNormally(f);
1082	–	}};
1083	–	testInvokeOnPool(singletonPool(), a);
1084	–	}
1085	–
1086	–	/**
1087	–	* helpQuiesce returns when tasks are complete.
1088	–	* getQueuedTaskCount returns 0 when quiescent
1089	–	*/
1090	–	public void testForkHelpQuiesceSingleton() {
1091	–	RecursiveAction a = new CheckedRecursiveAction() {
1092	–	protected void realCompute() {
1093	–	AsyncFib f = new AsyncFib(8);
1094	–	assertSame(f, f.fork());
1095	–	helpQuiesce();
1096	–	assertEquals(0, getQueuedTaskCount());
1097	–	assertEquals(21, f.number);
1098	–	checkCompletedNormally(f);
1099	–	}};
1100	–	testInvokeOnPool(singletonPool(), a);
1101	–	}
1102	–
1103	–	/**
1104	–	* invoke task throws exception when task completes abnormally
1105	–	*/
1106	–	public void testAbnormalInvokeSingleton() {
1107	–	RecursiveAction a = new CheckedRecursiveAction() {
1108	–	protected void realCompute() {
1109	–	FailingAsyncFib f = new FailingAsyncFib(8);
1110	–	try {
1111	–	f.invoke();
1112	–	shouldThrow();
1113	–	} catch (FJException success) {
1114	–	checkCompletedAbnormally(f, success);
1115	–	}
1116	–	}};
1117	–	testInvokeOnPool(singletonPool(), a);
1118	–	}
1119	–
1120	–	/**
1121	–	* quietlyInvoke task returns when task completes abnormally
1122	–	*/
1123	–	public void testAbnormalQuietlyInvokeSingleton() {
1124	–	RecursiveAction a = new CheckedRecursiveAction() {
1125	–	protected void realCompute() {
1126	–	FailingAsyncFib f = new FailingAsyncFib(8);
1127	–	f.quietlyInvoke();
1128	–	assertTrue(f.getException() instanceof FJException);
1129	–	checkCompletedAbnormally(f, f.getException());
1130	–	}};
1131	–	testInvokeOnPool(singletonPool(), a);
1132	–	}
1133	–
1134	–	/**
1135	–	* join of a forked task throws exception when task completes abnormally
1136	–	*/
1137	–	public void testAbnormalForkJoinSingleton() {
1138	–	RecursiveAction a = new CheckedRecursiveAction() {
1139	–	protected void realCompute() {
1140	–	FailingAsyncFib f = new FailingAsyncFib(8);
1141	–	assertSame(f, f.fork());
1142	–	try {
1143	–	f.join();
1144	–	shouldThrow();
1145	–	} catch (FJException success) {
1146	–	checkCompletedAbnormally(f, success);
1147	–	}
1148	–	}};
1149	–	testInvokeOnPool(singletonPool(), a);
1150	–	}
1151	–
1152	–	/**
1153	–	* get of a forked task throws exception when task completes abnormally
1154	–	*/
1155	–	public void testAbnormalForkGetSingleton() {
1156	–	RecursiveAction a = new CheckedRecursiveAction() {
1157	–	protected void realCompute() throws Exception {
1158	–	FailingAsyncFib f = new FailingAsyncFib(8);
1159	–	assertSame(f, f.fork());
1160	–	try {
1161	–	f.get();
1162	–	shouldThrow();
1163	–	} catch (ExecutionException success) {
1164	–	Throwable cause = success.getCause();
1165	–	assertTrue(cause instanceof FJException);
1166	–	checkCompletedAbnormally(f, cause);
1167	–	}
1168	–	}};
1169	–	testInvokeOnPool(singletonPool(), a);
1170	–	}
1171	–
1172	–	/**
1173	–	* timed get of a forked task throws exception when task completes abnormally
1174	–	*/
1175	–	public void testAbnormalForkTimedGetSingleton() {
1176	–	RecursiveAction a = new CheckedRecursiveAction() {
1177	–	protected void realCompute() throws Exception {
1178	–	FailingAsyncFib f = new FailingAsyncFib(8);
1179	–	assertSame(f, f.fork());
1180	–	try {
1181	–	f.get(LONG_DELAY_MS, MILLISECONDS);
1182	–	shouldThrow();
1183	–	} catch (ExecutionException success) {
1184	–	Throwable cause = success.getCause();
1185	–	assertTrue(cause instanceof FJException);
1186	–	checkCompletedAbnormally(f, cause);
1187	–	}
1188	–	}};
1189	–	testInvokeOnPool(singletonPool(), a);
1190	–	}
1191	–
1192	–	/**
1193	–	* quietlyJoin of a forked task returns when task completes abnormally
1194	–	*/
1195	–	public void testAbnormalForkQuietlyJoinSingleton() {
1196	–	RecursiveAction a = new CheckedRecursiveAction() {
1197	–	protected void realCompute() {
1198	–	FailingAsyncFib f = new FailingAsyncFib(8);
1199	–	assertSame(f, f.fork());
1200	–	f.quietlyJoin();
1201	–	assertTrue(f.getException() instanceof FJException);
1202	–	checkCompletedAbnormally(f, f.getException());
1203	–	}};
1204	–	testInvokeOnPool(singletonPool(), a);
1205	–	}
1206	–
1207	–	/**
1208	–	* invoke task throws exception after invoking completeExceptionally
1209	–	*/
1210	–	public void testCompleteExceptionallySingleton() {
1211	–	RecursiveAction a = new CheckedRecursiveAction() {
1212	–	protected void realCompute() {
1213	–	AsyncFib f = new AsyncFib(8);
1214	–	f.completeExceptionally(new FJException());
1215	–	try {
1216	–	f.invoke();
1217	–	shouldThrow();
1218	–	} catch (FJException success) {
1219	–	checkCompletedAbnormally(f, success);
1220	–	}
1221	–	}};
1222	–	testInvokeOnPool(singletonPool(), a);
1223	–	}
1224	–
1225	–	/**
1226	–	* invokeAll(t1, t2) invokes all task arguments
1227	–	*/
1228	–	public void testInvokeAll2Singleton() {
1229	–	RecursiveAction a = new CheckedRecursiveAction() {
1230	–	protected void realCompute() {
1231	–	AsyncFib f = new AsyncFib(8);
1232	–	AsyncFib g = new AsyncFib(9);
1233	–	invokeAll(f, g);
1234	–	assertEquals(21, f.number);
1235	–	assertEquals(34, g.number);
1236	–	checkCompletedNormally(f);
1237	–	checkCompletedNormally(g);
1238	–	}};
1239	–	testInvokeOnPool(singletonPool(), a);
1240	–	}
1241	–
1242	–	/**
1243	–	* invokeAll(tasks) with 1 argument invokes task
1244	–	*/
1245	–	public void testInvokeAll1Singleton() {
1246	–	RecursiveAction a = new CheckedRecursiveAction() {
1247	–	protected void realCompute() {
1248	–	AsyncFib f = new AsyncFib(8);
1249	–	invokeAll(f);
1250	–	checkCompletedNormally(f);
1251	–	assertEquals(21, f.number);
1252	–	}};
1253	–	testInvokeOnPool(singletonPool(), a);
1254	–	}
1255	–
1256	–	/**
1257	–	* invokeAll(tasks) with > 2 argument invokes tasks
1258	–	*/
1259	–	public void testInvokeAll3Singleton() {
1260	–	RecursiveAction a = new CheckedRecursiveAction() {
1261	–	protected void realCompute() {
1262	–	AsyncFib f = new AsyncFib(8);
1263	–	AsyncFib g = new AsyncFib(9);
1264	–	AsyncFib h = new AsyncFib(7);
1265	–	invokeAll(f, g, h);
1266	–	assertEquals(21, f.number);
1267	–	assertEquals(34, g.number);
1268	–	assertEquals(13, h.number);
1269	–	checkCompletedNormally(f);
1270	–	checkCompletedNormally(g);
1271	–	checkCompletedNormally(h);
1272	–	}};
1273	–	testInvokeOnPool(singletonPool(), a);
1274	–	}
1275	–
1276	–	/**
1277	–	* invokeAll(collection) invokes all tasks in the collection
1278	–	*/
1279	–	public void testInvokeAllCollectionSingleton() {
1280	–	RecursiveAction a = new CheckedRecursiveAction() {
1281	–	protected void realCompute() {
1282	–	AsyncFib f = new AsyncFib(8);
1283	–	AsyncFib g = new AsyncFib(9);
1284	–	AsyncFib h = new AsyncFib(7);
1285	–	HashSet set = new HashSet();
1286	–	set.add(f);
1287	–	set.add(g);
1288	–	set.add(h);
1289	–	invokeAll(set);
1290	–	assertEquals(21, f.number);
1291	–	assertEquals(34, g.number);
1292	–	assertEquals(13, h.number);
1293	–	checkCompletedNormally(f);
1294	–	checkCompletedNormally(g);
1295	–	checkCompletedNormally(h);
1296	–	}};
1297	–	testInvokeOnPool(singletonPool(), a);
1298	–	}
1299	–
1300	–	/**
1301	–	* invokeAll(tasks) with any null task throws NPE
1302	–	*/
1303	–	public void testInvokeAllNPESingleton() {
1304	–	RecursiveAction a = new CheckedRecursiveAction() {
1305	–	protected void realCompute() {
1306	–	AsyncFib f = new AsyncFib(8);
1307	–	AsyncFib g = new AsyncFib(9);
1308	–	AsyncFib h = null;
1309	–	try {
1310	–	invokeAll(f, g, h);
1311	–	shouldThrow();
1312	–	} catch (NullPointerException success) {}
1313	–	}};
1314	–	testInvokeOnPool(singletonPool(), a);
1315	–	}
1316	–
1317	–	/**
1318	–	* invokeAll(t1, t2) throw exception if any task does
1319	–	*/
1320	–	public void testAbnormalInvokeAll2Singleton() {
1321	–	RecursiveAction a = new CheckedRecursiveAction() {
1322	–	protected void realCompute() {
1323	–	AsyncFib f = new AsyncFib(8);
1324	–	FailingAsyncFib g = new FailingAsyncFib(9);
1325	–	try {
1326	–	invokeAll(f, g);
1327	–	shouldThrow();
1328	–	} catch (FJException success) {
1329	–	checkCompletedAbnormally(g, success);
1330	–	}
1331	–	}};
1332	–	testInvokeOnPool(singletonPool(), a);
1333	–	}
1334	–
1335	–	/**
1336	–	* invokeAll(tasks) with 1 argument throws exception if task does
1337	–	*/
1338	–	public void testAbnormalInvokeAll1Singleton() {
1339	–	RecursiveAction a = new CheckedRecursiveAction() {
1340	–	protected void realCompute() {
1341	–	FailingAsyncFib g = new FailingAsyncFib(9);
1342	–	try {
1343	–	invokeAll(g);
1344	–	shouldThrow();
1345	–	} catch (FJException success) {
1346	–	checkCompletedAbnormally(g, success);
1347	–	}
1348	–	}};
1349	–	testInvokeOnPool(singletonPool(), a);
1350	–	}
1351	–
1352	–	/**
1353	–	* invokeAll(tasks) with > 2 argument throws exception if any task does
1354	–	*/
1355	–	public void testAbnormalInvokeAll3Singleton() {
1356	–	RecursiveAction a = new CheckedRecursiveAction() {
1357	–	protected void realCompute() {
1358	–	AsyncFib f = new AsyncFib(8);
1359	–	FailingAsyncFib g = new FailingAsyncFib(9);
1360	–	AsyncFib h = new AsyncFib(7);
1361	–	try {
1362	–	invokeAll(f, g, h);
1363	–	shouldThrow();
1364	–	} catch (FJException success) {
1365	–	checkCompletedAbnormally(g, success);
1366	–	}
1367	–	}};
1368	–	testInvokeOnPool(singletonPool(), a);
1369	–	}
1370	–
1371	–	/**
1372	–	* invokeAll(collection) throws exception if any task does
1373	–	*/
1374	–	public void testAbnormalInvokeAllCollectionSingleton() {
1375	–	RecursiveAction a = new CheckedRecursiveAction() {
1376	–	protected void realCompute() {
1377	–	FailingAsyncFib f = new FailingAsyncFib(8);
1378	–	AsyncFib g = new AsyncFib(9);
1379	–	AsyncFib h = new AsyncFib(7);
1380	–	HashSet set = new HashSet();
1381	–	set.add(f);
1382	–	set.add(g);
1383	–	set.add(h);
1384	–	try {
1385	–	invokeAll(set);
1386	–	shouldThrow();
1387	–	} catch (FJException success) {
1388	–	checkCompletedAbnormally(f, success);
1389	–	}
1390	–	}};
1391	–	testInvokeOnPool(singletonPool(), a);
1392	–	}
1393	–
1136		/**
1137		* ForkJoinTask.quietlyComplete returns when task completes
1138		* normally without setting a value. The most recent value
#	Line 1412 | Line 1154 | public class ForkJoinTask8Test extends J
1154		testInvokeOnPool(mainPool(), a);
1155		}
1156
1157	+	// jdk9
1158	+
1159	+	/**
1160	+	* pollSubmission returns unexecuted submitted task, if present
1161	+	*/
1162	+	public void testPollSubmission() {
1163	+	final CountDownLatch done = new CountDownLatch(1);
1164	+	final ForkJoinTask a = ForkJoinTask.adapt(awaiter(done));
1165	+	final ForkJoinTask b = ForkJoinTask.adapt(awaiter(done));
1166	+	final ForkJoinTask c = ForkJoinTask.adapt(awaiter(done));
1167	+	final ForkJoinPool p = singletonPool();
1168	+	Thread external = new Thread() {
1169	+	public void run() {
1170	+	p.execute(a);
1171	+	p.execute(b);
1172	+	p.execute(c);
1173	+	}};
1174	+	RecursiveAction s = new CheckedRecursiveAction() {
1175	+	protected void realCompute() {
1176	+	external.start();
1177	+	try {
1178	+	external.join();
1179	+	} catch(Exception ex) {
1180	+	threadUnexpectedException(ex);
1181	+	}
1182	+	assertTrue(p.hasQueuedSubmissions());
1183	+	assertTrue(Thread.currentThread() instanceof ForkJoinWorkerThread);
1184	+	ForkJoinTask r = ForkJoinTask.pollSubmission();
1185	+	assertTrue(r == a || r == b || r == c);
1186	+	assertFalse(r.isDone());
1187	+	}};
1188	+	try {
1189	+	p.invoke(s);
1190	+	} finally {
1191	+	done.countDown();
1192	+	joinPool(p);
1193	+	}
1194	+	}
1195	+
1196	+
1197		}

Diff Legend

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