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.3 by jsr166, Mon Jul 22 18:01:03 2013 UTC vs.
Revision 1.26 by jsr166, Wed Aug 10 01:28:14 2016 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
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.concurrent.CountDownLatch;
13		import java.util.concurrent.ExecutionException;
7	–	import java.util.concurrent.CancellationException;
14		import java.util.concurrent.ForkJoinPool;
15		import java.util.concurrent.ForkJoinTask;
16		import java.util.concurrent.ForkJoinWorkerThread;
17		import java.util.concurrent.RecursiveAction;
12	–	import java.util.concurrent.TimeUnit;
18		import java.util.concurrent.TimeoutException;
19	<	import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
20	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21	<	import static java.util.concurrent.TimeUnit.SECONDS;
17	<	import java.util.HashSet;
18	<	import junit.framework.*;
19	>
20	>	import junit.framework.Test;
21	>	import junit.framework.TestSuite;
22
23		public class ForkJoinTask8Test extends JSR166TestCase {
24
#	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 {
77	>	try (PoolCleaner cleaner = cleaner(pool)) {
78		assertFalse(a.isDone());
79		assertFalse(a.isCompletedNormally());
80		assertFalse(a.isCompletedAbnormally());
#	Line 76 | Line 90 | public class ForkJoinTask8Test extends J
90		assertFalse(a.isCancelled());
91		assertNull(a.getException());
92		assertNull(a.getRawResult());
79	–	} finally {
80	–	joinPool(pool);
93		}
94		}
95
#	Line 114 | Line 126 | public class ForkJoinTask8Test extends J
126
127		{
128		Thread.currentThread().interrupt();
129	<	long t0 = System.nanoTime();
129	>	long startTime = System.nanoTime();
130		assertSame(expected, a.join());
131	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
131	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
132		Thread.interrupted();
133		}
134
135		{
136		Thread.currentThread().interrupt();
137	<	long t0 = System.nanoTime();
137	>	long startTime = System.nanoTime();
138		a.quietlyJoin();        // should be no-op
139	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
139	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
140		Thread.interrupted();
141		}
142
#	Line 160 | Line 172 | public class ForkJoinTask8Test extends J
172		Thread.interrupted();
173
174		{
175	<	long t0 = System.nanoTime();
175	>	long startTime = System.nanoTime();
176		a.quietlyJoin();        // should be no-op
177	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
177	>	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
178		}
179
180		try {
#	Line 180 | Line 192 | public class ForkJoinTask8Test extends J
192		} catch (Throwable fail) { threadUnexpectedException(fail); }
193		}
194
183	–
195		public static final class FJException extends RuntimeException {
196		FJException() { super(); }
197		}
198
199		abstract static class BinaryAsyncAction extends ForkJoinTask<Void> {
200
201	<	private BinaryAsyncAction parent;
201	>	private volatile BinaryAsyncAction parent;
202
203	<	private BinaryAsyncAction sibling;
203	>	private volatile BinaryAsyncAction sibling;
204
205		protected BinaryAsyncAction() {
206		setForkJoinTaskTag(INITIAL_STATE);
#	Line 232 | Line 243 | public class ForkJoinTask8Test extends J
243		super.completeExceptionally(ex);
244		}
245
246	+	public boolean cancel(boolean mayInterruptIfRunning) {
247	+	if (super.cancel(mayInterruptIfRunning)) {
248	+	completeExceptionally(new FJException());
249	+	return true;
250	+	}
251	+	return false;
252	+	}
253	+
254		public final void complete() {
255		BinaryAsyncAction a = this;
256		for (;;) {
#	Line 254 | Line 273 | public class ForkJoinTask8Test extends J
273		}
274
275		public final void completeExceptionally(Throwable ex) {
276	<	BinaryAsyncAction a = this;
258	<	while (!a.isCompletedAbnormally()) {
276	>	for (BinaryAsyncAction a = this;;) {
277		a.completeThisExceptionally(ex);
278		BinaryAsyncAction s = a.sibling;
279	<	if (s != null)
280	<	s.cancel(false);
281	<	if (!a.onException() || (a = a.parent) == null)
279	>	if (s != null && !s.isDone())
280	>	s.completeExceptionally(ex);
281	>	if ((a = a.parent) == null)
282		break;
283		}
284		}
#	Line 280 | Line 298 | public class ForkJoinTask8Test extends J
298
299		}
300
301	<	static final class AsyncFib extends BinaryAsyncAction {
301	>	final class AsyncFib extends BinaryAsyncAction {
302		int number;
303	<	public AsyncFib(int n) {
304	<	this.number = n;
303	>	int expectedResult;
304	>	public AsyncFib(int number) {
305	>	this.number = number;
306	>	this.expectedResult = fib[number];
307		}
308
309		public final boolean exec() {
310		try {
311		AsyncFib f = this;
312		int n = f.number;
313	<	if (n > 1) {
314	<	while (n > 1) {
315	<	AsyncFib p = f;
316	<	AsyncFib r = new AsyncFib(n - 2);
317	<	f = new AsyncFib(--n);
318	<	p.linkSubtasks(r, f);
299	<	r.fork();
300	<	}
301	<	f.number = n;
313	>	while (n > 1) {
314	>	AsyncFib p = f;
315	>	AsyncFib r = new AsyncFib(n - 2);
316	>	f = new AsyncFib(--n);
317	>	p.linkSubtasks(r, f);
318	>	r.fork();
319		}
320		f.complete();
321		}
322		catch (Throwable ex) {
323		compareAndSetForkJoinTaskTag(INITIAL_STATE, EXCEPTION_STATE);
324		}
325	+	if (getForkJoinTaskTag() == EXCEPTION_STATE)
326	+	throw new FJException();
327		return false;
328		}
329
#	Line 312 | Line 331 | public class ForkJoinTask8Test extends J
331		number = ((AsyncFib)x).number + ((AsyncFib)y).number;
332		super.onComplete(x, y);
333		}
334	+
335	+	public void checkCompletedNormally() {
336	+	assertEquals(expectedResult, number);
337	+	ForkJoinTask8Test.this.checkCompletedNormally(this);
338	+	}
339		}
340
341		static final class FailingAsyncFib extends BinaryAsyncAction {
#	Line 321 | Line 345 | public class ForkJoinTask8Test extends J
345		}
346
347		public final boolean exec() {
348	<	FailingAsyncFib f = this;
349	<	int n = f.number;
350	<	if (n > 1) {
348	>	try {
349	>	FailingAsyncFib f = this;
350	>	int n = f.number;
351		while (n > 1) {
352		FailingAsyncFib p = f;
353		FailingAsyncFib r = new FailingAsyncFib(n - 2);
#	Line 331 | Line 355 | public class ForkJoinTask8Test extends J
355		p.linkSubtasks(r, f);
356		r.fork();
357		}
358	<	f.number = n;
358	>	f.complete();
359		}
360	<	f.complete();
360	>	catch (Throwable ex) {
361	>	compareAndSetForkJoinTaskTag(INITIAL_STATE, EXCEPTION_STATE);
362	>	}
363	>	if (getForkJoinTaskTag() == EXCEPTION_STATE)
364	>	throw new FJException();
365		return false;
366		}
367
#	Line 348 | Line 376 | public class ForkJoinTask8Test extends J
376		* completed tasks; getRawResult returns null.
377		*/
378		public void testInvoke() {
379	+	testInvoke(mainPool());
380	+	}
381	+	public void testInvoke_Singleton() {
382	+	testInvoke(singletonPool());
383	+	}
384	+	public void testInvoke(ForkJoinPool pool) {
385		RecursiveAction a = new CheckedRecursiveAction() {
386		protected void realCompute() {
387		AsyncFib f = new AsyncFib(8);
388		assertNull(f.invoke());
389	<	assertEquals(21, f.number);
356	<	checkCompletedNormally(f);
389	>	f.checkCompletedNormally();
390		}};
391	<	testInvokeOnPool(mainPool(), a);
391	>	testInvokeOnPool(pool, a);
392		}
393
394		/**
#	Line 364 | Line 397 | public class ForkJoinTask8Test extends J
397		* completed tasks
398		*/
399		public void testQuietlyInvoke() {
400	+	testQuietlyInvoke(mainPool());
401	+	}
402	+	public void testQuietlyInvoke_Singleton() {
403	+	testQuietlyInvoke(singletonPool());
404	+	}
405	+	public void testQuietlyInvoke(ForkJoinPool pool) {
406		RecursiveAction a = new CheckedRecursiveAction() {
407		protected void realCompute() {
408		AsyncFib f = new AsyncFib(8);
409		f.quietlyInvoke();
410	<	assertEquals(21, f.number);
372	<	checkCompletedNormally(f);
410	>	f.checkCompletedNormally();
411		}};
412	<	testInvokeOnPool(mainPool(), a);
412	>	testInvokeOnPool(pool, a);
413		}
414
415		/**
416		* join of a forked task returns when task completes
417		*/
418		public void testForkJoin() {
419	+	testForkJoin(mainPool());
420	+	}
421	+	public void testForkJoin_Singleton() {
422	+	testForkJoin(singletonPool());
423	+	}
424	+	public void testForkJoin(ForkJoinPool pool) {
425		RecursiveAction a = new CheckedRecursiveAction() {
426		protected void realCompute() {
427		AsyncFib f = new AsyncFib(8);
428		assertSame(f, f.fork());
429		assertNull(f.join());
430	<	assertEquals(21, f.number);
387	<	checkCompletedNormally(f);
430	>	f.checkCompletedNormally();
431		}};
432	<	testInvokeOnPool(mainPool(), a);
432	>	testInvokeOnPool(pool, a);
433		}
434
435		/**
436		* get of a forked task returns when task completes
437		*/
438		public void testForkGet() {
439	+	testForkGet(mainPool());
440	+	}
441	+	public void testForkGet_Singleton() {
442	+	testForkGet(singletonPool());
443	+	}
444	+	public void testForkGet(ForkJoinPool pool) {
445		RecursiveAction a = new CheckedRecursiveAction() {
446		protected void realCompute() throws Exception {
447		AsyncFib f = new AsyncFib(8);
448		assertSame(f, f.fork());
449		assertNull(f.get());
450	<	assertEquals(21, f.number);
402	<	checkCompletedNormally(f);
450	>	f.checkCompletedNormally();
451		}};
452	<	testInvokeOnPool(mainPool(), a);
452	>	testInvokeOnPool(pool, a);
453		}
454
455		/**
456		* timed get of a forked task returns when task completes
457		*/
458		public void testForkTimedGet() {
459	+	testForkTimedGet(mainPool());
460	+	}
461	+	public void testForkTimedGet_Singleton() {
462	+	testForkTimedGet(singletonPool());
463	+	}
464	+	public void testForkTimedGet(ForkJoinPool pool) {
465		RecursiveAction a = new CheckedRecursiveAction() {
466		protected void realCompute() throws Exception {
467		AsyncFib f = new AsyncFib(8);
468		assertSame(f, f.fork());
469		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
470	<	assertEquals(21, f.number);
417	<	checkCompletedNormally(f);
470	>	f.checkCompletedNormally();
471		}};
472	<	testInvokeOnPool(mainPool(), a);
472	>	testInvokeOnPool(pool, a);
473		}
474
475		/**
476	<	* timed get with null time unit throws NPE
476	>	* timed get with null time unit throws NullPointerException
477		*/
478	<	public void testForkTimedGetNPE() {
478	>	public void testForkTimedGetNullTimeUnit() {
479	>	testForkTimedGetNullTimeUnit(mainPool());
480	>	}
481	>	public void testForkTimedGetNullTimeUnit_Singleton() {
482	>	testForkTimedGet(singletonPool());
483	>	}
484	>	public void testForkTimedGetNullTimeUnit(ForkJoinPool pool) {
485		RecursiveAction a = new CheckedRecursiveAction() {
486		protected void realCompute() throws Exception {
487		AsyncFib f = new AsyncFib(8);
#	Line 432 | Line 491 | public class ForkJoinTask8Test extends J
491		shouldThrow();
492		} catch (NullPointerException success) {}
493		}};
494	<	testInvokeOnPool(mainPool(), a);
494	>	testInvokeOnPool(pool, a);
495		}
496
497		/**
498		* quietlyJoin of a forked task returns when task completes
499		*/
500		public void testForkQuietlyJoin() {
501	+	testForkQuietlyJoin(mainPool());
502	+	}
503	+	public void testForkQuietlyJoin_Singleton() {
504	+	testForkQuietlyJoin(singletonPool());
505	+	}
506	+	public void testForkQuietlyJoin(ForkJoinPool pool) {
507		RecursiveAction a = new CheckedRecursiveAction() {
508		protected void realCompute() {
509		AsyncFib f = new AsyncFib(8);
510		assertSame(f, f.fork());
511		f.quietlyJoin();
512	<	assertEquals(21, f.number);
448	<	checkCompletedNormally(f);
512	>	f.checkCompletedNormally();
513		}};
514	<	testInvokeOnPool(mainPool(), a);
514	>	testInvokeOnPool(pool, a);
515		}
516
517		/**
#	Line 455 | Line 519 | public class ForkJoinTask8Test extends J
519		* getQueuedTaskCount returns 0 when quiescent
520		*/
521		public void testForkHelpQuiesce() {
522	+	testForkHelpQuiesce(mainPool());
523	+	}
524	+	public void testForkHelpQuiesce_Singleton() {
525	+	testForkHelpQuiesce(singletonPool());
526	+	}
527	+	public void testForkHelpQuiesce(ForkJoinPool pool) {
528		RecursiveAction a = new CheckedRecursiveAction() {
529		protected void realCompute() {
530		AsyncFib f = new AsyncFib(8);
531		assertSame(f, f.fork());
532		helpQuiesce();
463	–	assertEquals(21, f.number);
533		assertEquals(0, getQueuedTaskCount());
534	<	checkCompletedNormally(f);
534	>	f.checkCompletedNormally();
535		}};
536	<	testInvokeOnPool(mainPool(), a);
536	>	testInvokeOnPool(pool, a);
537		}
538
539		/**
540		* invoke task throws exception when task completes abnormally
541		*/
542		public void testAbnormalInvoke() {
543	+	testAbnormalInvoke(mainPool());
544	+	}
545	+	public void testAbnormalInvoke_Singleton() {
546	+	testAbnormalInvoke(singletonPool());
547	+	}
548	+	public void testAbnormalInvoke(ForkJoinPool pool) {
549		RecursiveAction a = new CheckedRecursiveAction() {
550		protected void realCompute() {
551		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 481 | Line 556 | public class ForkJoinTask8Test extends J
556		checkCompletedAbnormally(f, success);
557		}
558		}};
559	<	testInvokeOnPool(mainPool(), a);
559	>	testInvokeOnPool(pool, a);
560		}
561
562		/**
563		* quietlyInvoke task returns when task completes abnormally
564		*/
565		public void testAbnormalQuietlyInvoke() {
566	+	testAbnormalQuietlyInvoke(mainPool());
567	+	}
568	+	public void testAbnormalQuietlyInvoke_Singleton() {
569	+	testAbnormalQuietlyInvoke(singletonPool());
570	+	}
571	+	public void testAbnormalQuietlyInvoke(ForkJoinPool pool) {
572		RecursiveAction a = new CheckedRecursiveAction() {
573		protected void realCompute() {
574		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 495 | Line 576 | public class ForkJoinTask8Test extends J
576		assertTrue(f.getException() instanceof FJException);
577		checkCompletedAbnormally(f, f.getException());
578		}};
579	<	testInvokeOnPool(mainPool(), a);
579	>	testInvokeOnPool(pool, a);
580		}
581
582		/**
583		* join of a forked task throws exception when task completes abnormally
584		*/
585		public void testAbnormalForkJoin() {
586	+	testAbnormalForkJoin(mainPool());
587	+	}
588	+	public void testAbnormalForkJoin_Singleton() {
589	+	testAbnormalForkJoin(singletonPool());
590	+	}
591	+	public void testAbnormalForkJoin(ForkJoinPool pool) {
592		RecursiveAction a = new CheckedRecursiveAction() {
593		protected void realCompute() {
594		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 513 | Line 600 | public class ForkJoinTask8Test extends J
600		checkCompletedAbnormally(f, success);
601		}
602		}};
603	<	testInvokeOnPool(mainPool(), a);
603	>	testInvokeOnPool(pool, a);
604		}
605
606		/**
607		* get of a forked task throws exception when task completes abnormally
608		*/
609		public void testAbnormalForkGet() {
610	+	testAbnormalForkGet(mainPool());
611	+	}
612	+	public void testAbnormalForkGet_Singleton() {
613	+	testAbnormalForkJoin(singletonPool());
614	+	}
615	+	public void testAbnormalForkGet(ForkJoinPool pool) {
616		RecursiveAction a = new CheckedRecursiveAction() {
617		protected void realCompute() throws Exception {
618		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 533 | Line 626 | public class ForkJoinTask8Test extends J
626		checkCompletedAbnormally(f, cause);
627		}
628		}};
629	<	testInvokeOnPool(mainPool(), a);
629	>	testInvokeOnPool(pool, a);
630		}
631
632		/**
633		* timed get of a forked task throws exception when task completes abnormally
634		*/
635		public void testAbnormalForkTimedGet() {
636	+	testAbnormalForkTimedGet(mainPool());
637	+	}
638	+	public void testAbnormalForkTimedGet_Singleton() {
639	+	testAbnormalForkTimedGet(singletonPool());
640	+	}
641	+	public void testAbnormalForkTimedGet(ForkJoinPool pool) {
642		RecursiveAction a = new CheckedRecursiveAction() {
643		protected void realCompute() throws Exception {
644		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 553 | Line 652 | public class ForkJoinTask8Test extends J
652		checkCompletedAbnormally(f, cause);
653		}
654		}};
655	<	testInvokeOnPool(mainPool(), a);
655	>	testInvokeOnPool(pool, a);
656		}
657
658		/**
659		* quietlyJoin of a forked task returns when task completes abnormally
660		*/
661		public void testAbnormalForkQuietlyJoin() {
662	+	testAbnormalForkQuietlyJoin(mainPool());
663	+	}
664	+	public void testAbnormalForkQuietlyJoin_Singleton() {
665	+	testAbnormalForkQuietlyJoin(singletonPool());
666	+	}
667	+	public void testAbnormalForkQuietlyJoin(ForkJoinPool pool) {
668		RecursiveAction a = new CheckedRecursiveAction() {
669		protected void realCompute() {
670		FailingAsyncFib f = new FailingAsyncFib(8);
#	Line 568 | Line 673 | public class ForkJoinTask8Test extends J
673		assertTrue(f.getException() instanceof FJException);
674		checkCompletedAbnormally(f, f.getException());
675		}};
676	<	testInvokeOnPool(mainPool(), a);
676	>	testInvokeOnPool(pool, a);
677		}
678
679		/**
680		* getPool of executing task returns its pool
681		*/
682		public void testGetPool() {
683	<	final ForkJoinPool mainPool = mainPool();
683	>	testGetPool(mainPool());
684	>	}
685	>	public void testGetPool_Singleton() {
686	>	testGetPool(singletonPool());
687	>	}
688	>	public void testGetPool(ForkJoinPool pool) {
689		RecursiveAction a = new CheckedRecursiveAction() {
690		protected void realCompute() {
691	<	assertSame(mainPool, getPool());
691	>	assertSame(pool, getPool());
692		}};
693	<	testInvokeOnPool(mainPool, a);
693	>	testInvokeOnPool(pool, a);
694		}
695
696		/**
#	Line 598 | Line 708 | public class ForkJoinTask8Test extends J
708		* inForkJoinPool of executing task returns true
709		*/
710		public void testInForkJoinPool() {
711	+	testInForkJoinPool(mainPool());
712	+	}
713	+	public void testInForkJoinPool_Singleton() {
714	+	testInForkJoinPool(singletonPool());
715	+	}
716	+	public void testInForkJoinPool(ForkJoinPool pool) {
717		RecursiveAction a = new CheckedRecursiveAction() {
718		protected void realCompute() {
719		assertTrue(inForkJoinPool());
720		}};
721	<	testInvokeOnPool(mainPool(), a);
721	>	testInvokeOnPool(pool, a);
722		}
723
724		/**
#	Line 632 | Line 748 | public class ForkJoinTask8Test extends J
748		* invoke task throws exception after invoking completeExceptionally
749		*/
750		public void testCompleteExceptionally() {
751	+	testCompleteExceptionally(mainPool());
752	+	}
753	+	public void testCompleteExceptionally_Singleton() {
754	+	testCompleteExceptionally(singletonPool());
755	+	}
756	+	public void testCompleteExceptionally(ForkJoinPool pool) {
757		RecursiveAction a = new CheckedRecursiveAction() {
758		protected void realCompute() {
759		AsyncFib f = new AsyncFib(8);
#	Line 643 | Line 765 | public class ForkJoinTask8Test extends J
765		checkCompletedAbnormally(f, success);
766		}
767		}};
768	<	testInvokeOnPool(mainPool(), a);
768	>	testInvokeOnPool(pool, a);
769		}
770
771		/**
772	<	* invokeAll(t1, t2) invokes all task arguments
772	>	* invokeAll(tasks) with 1 argument invokes task
773		*/
774	<	public void testInvokeAll2() {
774	>	public void testInvokeAll1() {
775	>	testInvokeAll1(mainPool());
776	>	}
777	>	public void testInvokeAll1_Singleton() {
778	>	testInvokeAll1(singletonPool());
779	>	}
780	>	public void testInvokeAll1(ForkJoinPool pool) {
781		RecursiveAction a = new CheckedRecursiveAction() {
782		protected void realCompute() {
783		AsyncFib f = new AsyncFib(8);
784	<	AsyncFib g = new AsyncFib(9);
785	<	invokeAll(f, g);
658	<	assertEquals(21, f.number);
659	<	assertEquals(34, g.number);
660	<	checkCompletedNormally(f);
661	<	checkCompletedNormally(g);
784	>	invokeAll(f);
785	>	f.checkCompletedNormally();
786		}};
787	<	testInvokeOnPool(mainPool(), a);
787	>	testInvokeOnPool(pool, a);
788		}
789
790		/**
791	<	* invokeAll(tasks) with 1 argument invokes task
791	>	* invokeAll(t1, t2) invokes all task arguments
792		*/
793	<	public void testInvokeAll1() {
793	>	public void testInvokeAll2() {
794	>	testInvokeAll2(mainPool());
795	>	}
796	>	public void testInvokeAll2_Singleton() {
797	>	testInvokeAll2(singletonPool());
798	>	}
799	>	public void testInvokeAll2(ForkJoinPool pool) {
800		RecursiveAction a = new CheckedRecursiveAction() {
801		protected void realCompute() {
802	<	AsyncFib f = new AsyncFib(8);
803	<	invokeAll(f);
804	<	checkCompletedNormally(f);
805	<	assertEquals(21, f.number);
802	>	AsyncFib[] tasks = {
803	>	new AsyncFib(8),
804	>	new AsyncFib(9),
805	>	};
806	>	invokeAll(tasks[0], tasks[1]);
807	>	for (AsyncFib task : tasks) assertTrue(task.isDone());
808	>	for (AsyncFib task : tasks) task.checkCompletedNormally();
809		}};
810	<	testInvokeOnPool(mainPool(), a);
810	>	testInvokeOnPool(pool, a);
811		}
812
813		/**
814		* invokeAll(tasks) with > 2 argument invokes tasks
815		*/
816		public void testInvokeAll3() {
817	+	testInvokeAll3(mainPool());
818	+	}
819	+	public void testInvokeAll3_Singleton() {
820	+	testInvokeAll3(singletonPool());
821	+	}
822	+	public void testInvokeAll3(ForkJoinPool pool) {
823		RecursiveAction a = new CheckedRecursiveAction() {
824		protected void realCompute() {
825	<	AsyncFib f = new AsyncFib(8);
826	<	AsyncFib g = new AsyncFib(9);
827	<	AsyncFib h = new AsyncFib(7);
828	<	invokeAll(f, g, h);
829	<	assertEquals(21, f.number);
830	<	assertEquals(34, g.number);
831	<	assertEquals(13, h.number);
832	<	checkCompletedNormally(f);
694	<	checkCompletedNormally(g);
695	<	checkCompletedNormally(h);
825	>	AsyncFib[] tasks = {
826	>	new AsyncFib(8),
827	>	new AsyncFib(9),
828	>	new AsyncFib(7),
829	>	};
830	>	invokeAll(tasks[0], tasks[1], tasks[2]);
831	>	for (AsyncFib task : tasks) assertTrue(task.isDone());
832	>	for (AsyncFib task : tasks) task.checkCompletedNormally();
833		}};
834	<	testInvokeOnPool(mainPool(), a);
834	>	testInvokeOnPool(pool, a);
835		}
836
837		/**
838		* invokeAll(collection) invokes all tasks in the collection
839		*/
840		public void testInvokeAllCollection() {
841	+	testInvokeAllCollection(mainPool());
842	+	}
843	+	public void testInvokeAllCollection_Singleton() {
844	+	testInvokeAllCollection(singletonPool());
845	+	}
846	+	public void testInvokeAllCollection(ForkJoinPool pool) {
847		RecursiveAction a = new CheckedRecursiveAction() {
848		protected void realCompute() {
849	<	AsyncFib f = new AsyncFib(8);
850	<	AsyncFib g = new AsyncFib(9);
851	<	AsyncFib h = new AsyncFib(7);
852	<	HashSet set = new HashSet();
853	<	set.add(f);
854	<	set.add(g);
855	<	set.add(h);
856	<	invokeAll(set);
714	<	assertEquals(21, f.number);
715	<	assertEquals(34, g.number);
716	<	assertEquals(13, h.number);
717	<	checkCompletedNormally(f);
718	<	checkCompletedNormally(g);
719	<	checkCompletedNormally(h);
849	>	AsyncFib[] tasks = {
850	>	new AsyncFib(8),
851	>	new AsyncFib(9),
852	>	new AsyncFib(7),
853	>	};
854	>	invokeAll(Arrays.asList(tasks));
855	>	for (AsyncFib task : tasks) assertTrue(task.isDone());
856	>	for (AsyncFib task : tasks) task.checkCompletedNormally();
857		}};
858	<	testInvokeOnPool(mainPool(), a);
858	>	testInvokeOnPool(pool, a);
859		}
860
861		/**
862	<	* invokeAll(tasks) with any null task throws NPE
862	>	* invokeAll(tasks) with any null task throws NullPointerException
863		*/
864	<	public void testInvokeAllNPE() {
864	>	public void testInvokeAllNullTask() {
865	>	testInvokeAllNullTask(mainPool());
866	>	}
867	>	public void testInvokeAllNullTask_Singleton() {
868	>	testInvokeAllNullTask(singletonPool());
869	>	}
870	>	public void testInvokeAllNullTask(ForkJoinPool pool) {
871		RecursiveAction a = new CheckedRecursiveAction() {
872		protected void realCompute() {
873	<	AsyncFib f = new AsyncFib(8);
874	<	AsyncFib g = new AsyncFib(9);
875	<	AsyncFib h = null;
876	<	try {
877	<	invokeAll(f, g, h);
878	<	shouldThrow();
879	<	} catch (NullPointerException success) {}
873	>	AsyncFib nul = null;
874	>	Runnable[] throwingActions = {
875	>	() -> invokeAll(nul),
876	>	() -> invokeAll(nul, nul),
877	>	() -> invokeAll(new AsyncFib(8), new AsyncFib(9), nul),
878	>	() -> invokeAll(new AsyncFib(8), nul, new AsyncFib(9)),
879	>	() -> invokeAll(nul, new AsyncFib(8), new AsyncFib(9)),
880	>	};
881	>	assertThrows(NullPointerException.class, throwingActions);
882		}};
883	<	testInvokeOnPool(mainPool(), a);
883	>	testInvokeOnPool(pool, a);
884		}
885
886		/**
887	<	* invokeAll(t1, t2) throw exception if any task does
887	>	* invokeAll(tasks) with 1 argument throws exception if task does
888		*/
889	<	public void testAbnormalInvokeAll2() {
889	>	public void testAbnormalInvokeAll1() {
890	>	testAbnormalInvokeAll1(mainPool());
891	>	}
892	>	public void testAbnormalInvokeAll1_Singleton() {
893	>	testAbnormalInvokeAll1(singletonPool());
894	>	}
895	>	public void testAbnormalInvokeAll1(ForkJoinPool pool) {
896		RecursiveAction a = new CheckedRecursiveAction() {
897		protected void realCompute() {
747	–	AsyncFib f = new AsyncFib(8);
898		FailingAsyncFib g = new FailingAsyncFib(9);
899		try {
900	<	invokeAll(f, g);
900	>	invokeAll(g);
901		shouldThrow();
902		} catch (FJException success) {
903		checkCompletedAbnormally(g, success);
904		}
905		}};
906	<	testInvokeOnPool(mainPool(), a);
906	>	testInvokeOnPool(pool, a);
907		}
908
909		/**
910	<	* invokeAll(tasks) with 1 argument throws exception if task does
910	>	* invokeAll(t1, t2) throw exception if any task does
911		*/
912	<	public void testAbnormalInvokeAll1() {
912	>	public void testAbnormalInvokeAll2() {
913	>	testAbnormalInvokeAll2(mainPool());
914	>	}
915	>	public void testAbnormalInvokeAll2_Singleton() {
916	>	testAbnormalInvokeAll2(singletonPool());
917	>	}
918	>	public void testAbnormalInvokeAll2(ForkJoinPool pool) {
919		RecursiveAction a = new CheckedRecursiveAction() {
920		protected void realCompute() {
921	+	AsyncFib f = new AsyncFib(8);
922		FailingAsyncFib g = new FailingAsyncFib(9);
923	+	ForkJoinTask[] tasks = { f, g };
924	+	shuffle(tasks);
925		try {
926	<	invokeAll(g);
926	>	invokeAll(tasks[0], tasks[1]);
927		shouldThrow();
928		} catch (FJException success) {
929		checkCompletedAbnormally(g, success);
930		}
931		}};
932	<	testInvokeOnPool(mainPool(), a);
932	>	testInvokeOnPool(pool, a);
933		}
934
935		/**
936		* invokeAll(tasks) with > 2 argument throws exception if any task does
937		*/
938		public void testAbnormalInvokeAll3() {
939	+	testAbnormalInvokeAll3(mainPool());
940	+	}
941	+	public void testAbnormalInvokeAll3_Singleton() {
942	+	testAbnormalInvokeAll3(singletonPool());
943	+	}
944	+	public void testAbnormalInvokeAll3(ForkJoinPool pool) {
945		RecursiveAction a = new CheckedRecursiveAction() {
946		protected void realCompute() {
947		AsyncFib f = new AsyncFib(8);
948		FailingAsyncFib g = new FailingAsyncFib(9);
949		AsyncFib h = new AsyncFib(7);
950	+	ForkJoinTask[] tasks = { f, g, h };
951	+	shuffle(tasks);
952		try {
953	<	invokeAll(f, g, h);
953	>	invokeAll(tasks[0], tasks[1], tasks[2]);
954		shouldThrow();
955		} catch (FJException success) {
956		checkCompletedAbnormally(g, success);
957		}
958		}};
959	<	testInvokeOnPool(mainPool(), a);
959	>	testInvokeOnPool(pool, a);
960		}
961
962		/**
963	<	* invokeAll(collection)  throws exception if any task does
963	>	* invokeAll(collection) throws exception if any task does
964		*/
965		public void testAbnormalInvokeAllCollection() {
966	+	testAbnormalInvokeAllCollection(mainPool());
967	+	}
968	+	public void testAbnormalInvokeAllCollection_Singleton() {
969	+	testAbnormalInvokeAllCollection(singletonPool());
970	+	}
971	+	public void testAbnormalInvokeAllCollection(ForkJoinPool pool) {
972		RecursiveAction a = new CheckedRecursiveAction() {
973		protected void realCompute() {
974		FailingAsyncFib f = new FailingAsyncFib(8);
975		AsyncFib g = new AsyncFib(9);
976		AsyncFib h = new AsyncFib(7);
977	<	HashSet set = new HashSet();
978	<	set.add(f);
806	<	set.add(g);
807	<	set.add(h);
977	>	ForkJoinTask[] tasks = { f, g, h };
978	>	shuffle(tasks);
979		try {
980	<	invokeAll(set);
980	>	invokeAll(Arrays.asList(tasks));
981		shouldThrow();
982		} catch (FJException success) {
983		checkCompletedAbnormally(f, success);
984		}
985		}};
986	<	testInvokeOnPool(mainPool(), a);
986	>	testInvokeOnPool(pool, a);
987		}
988
989		/**
#	Line 829 | Line 1000 | public class ForkJoinTask8Test extends J
1000		assertTrue(f.tryUnfork());
1001		helpQuiesce();
1002		checkNotDone(f);
1003	<	checkCompletedNormally(g);
1003	>	g.checkCompletedNormally();
1004		}};
1005		testInvokeOnPool(singletonPool(), a);
1006		}
#	Line 850 | Line 1021 | public class ForkJoinTask8Test extends J
1021		assertTrue(getSurplusQueuedTaskCount() > 0);
1022		helpQuiesce();
1023		assertEquals(0, getSurplusQueuedTaskCount());
1024	<	checkCompletedNormally(f);
1025	<	checkCompletedNormally(g);
1026	<	checkCompletedNormally(h);
1024	>	f.checkCompletedNormally();
1025	>	g.checkCompletedNormally();
1026	>	h.checkCompletedNormally();
1027		}};
1028		testInvokeOnPool(singletonPool(), a);
1029		}
#	Line 869 | Line 1040 | public class ForkJoinTask8Test extends J
1040		assertSame(f, f.fork());
1041		assertSame(f, peekNextLocalTask());
1042		assertNull(f.join());
1043	<	checkCompletedNormally(f);
1043	>	f.checkCompletedNormally();
1044		helpQuiesce();
1045	<	checkCompletedNormally(g);
1045	>	g.checkCompletedNormally();
1046		}};
1047		testInvokeOnPool(singletonPool(), a);
1048		}
#	Line 890 | Line 1061 | public class ForkJoinTask8Test extends J
1061		assertSame(f, pollNextLocalTask());
1062		helpQuiesce();
1063		checkNotDone(f);
1064	<	assertEquals(34, g.number);
894	<	checkCompletedNormally(g);
1064	>	g.checkCompletedNormally();
1065		}};
1066		testInvokeOnPool(singletonPool(), a);
1067		}
#	Line 909 | Line 1079 | public class ForkJoinTask8Test extends J
1079		assertSame(f, pollTask());
1080		helpQuiesce();
1081		checkNotDone(f);
1082	<	checkCompletedNormally(g);
1082	>	g.checkCompletedNormally();
1083		}};
1084		testInvokeOnPool(singletonPool(), a);
1085		}
#	Line 927 | Line 1097 | public class ForkJoinTask8Test extends J
1097		assertSame(g, peekNextLocalTask());
1098		assertNull(f.join());
1099		helpQuiesce();
1100	<	checkCompletedNormally(f);
1101	<	assertEquals(34, g.number);
932	<	checkCompletedNormally(g);
1100	>	f.checkCompletedNormally();
1101	>	g.checkCompletedNormally();
1102		}};
1103		testInvokeOnPool(asyncSingletonPool(), a);
1104		}
#	Line 947 | Line 1116 | public class ForkJoinTask8Test extends J
1116		assertSame(f, f.fork());
1117		assertSame(g, pollNextLocalTask());
1118		helpQuiesce();
1119	<	assertEquals(21, f.number);
951	<	checkCompletedNormally(f);
1119	>	f.checkCompletedNormally();
1120		checkNotDone(g);
1121		}};
1122		testInvokeOnPool(asyncSingletonPool(), a);
#	Line 967 | Line 1135 | public class ForkJoinTask8Test extends J
1135		assertSame(f, f.fork());
1136		assertSame(g, pollTask());
1137		helpQuiesce();
1138	<	assertEquals(21, f.number);
971	<	checkCompletedNormally(f);
1138	>	f.checkCompletedNormally();
1139		checkNotDone(g);
1140		}};
1141		testInvokeOnPool(asyncSingletonPool(), a);
1142		}
1143
977	–	// versions for singleton pools
978	–
979	–	/**
980	–	* invoke returns when task completes normally.
981	–	* isCompletedAbnormally and isCancelled return false for normally
982	–	* completed tasks; getRawResult returns null.
983	–	*/
984	–	public void testInvokeSingleton() {
985	–	RecursiveAction a = new CheckedRecursiveAction() {
986	–	protected void realCompute() {
987	–	AsyncFib f = new AsyncFib(8);
988	–	assertNull(f.invoke());
989	–	assertEquals(21, f.number);
990	–	checkCompletedNormally(f);
991	–	}};
992	–	testInvokeOnPool(singletonPool(), a);
993	–	}
994	–
995	–	/**
996	–	* quietlyInvoke task returns when task completes normally.
997	–	* isCompletedAbnormally and isCancelled return false for normally
998	–	* completed tasks
999	–	*/
1000	–	public void testQuietlyInvokeSingleton() {
1001	–	RecursiveAction a = new CheckedRecursiveAction() {
1002	–	protected void realCompute() {
1003	–	AsyncFib f = new AsyncFib(8);
1004	–	f.quietlyInvoke();
1005	–	assertEquals(21, f.number);
1006	–	checkCompletedNormally(f);
1007	–	}};
1008	–	testInvokeOnPool(singletonPool(), a);
1009	–	}
1010	–
1011	–	/**
1012	–	* join of a forked task returns when task completes
1013	–	*/
1014	–	public void testForkJoinSingleton() {
1015	–	RecursiveAction a = new CheckedRecursiveAction() {
1016	–	protected void realCompute() {
1017	–	AsyncFib f = new AsyncFib(8);
1018	–	assertSame(f, f.fork());
1019	–	assertNull(f.join());
1020	–	assertEquals(21, f.number);
1021	–	checkCompletedNormally(f);
1022	–	}};
1023	–	testInvokeOnPool(singletonPool(), a);
1024	–	}
1025	–
1026	–	/**
1027	–	* get of a forked task returns when task completes
1028	–	*/
1029	–	public void testForkGetSingleton() {
1030	–	RecursiveAction a = new CheckedRecursiveAction() {
1031	–	protected void realCompute() throws Exception {
1032	–	AsyncFib f = new AsyncFib(8);
1033	–	assertSame(f, f.fork());
1034	–	assertNull(f.get());
1035	–	assertEquals(21, f.number);
1036	–	checkCompletedNormally(f);
1037	–	}};
1038	–	testInvokeOnPool(singletonPool(), a);
1039	–	}
1040	–
1041	–	/**
1042	–	* timed get of a forked task returns when task completes
1043	–	*/
1044	–	public void testForkTimedGetSingleton() {
1045	–	RecursiveAction a = new CheckedRecursiveAction() {
1046	–	protected void realCompute() throws Exception {
1047	–	AsyncFib f = new AsyncFib(8);
1048	–	assertSame(f, f.fork());
1049	–	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
1050	–	assertEquals(21, f.number);
1051	–	checkCompletedNormally(f);
1052	–	}};
1053	–	testInvokeOnPool(singletonPool(), a);
1054	–	}
1055	–
1056	–	/**
1057	–	* timed get with null time unit throws NPE
1058	–	*/
1059	–	public void testForkTimedGetNPESingleton() {
1060	–	RecursiveAction a = new CheckedRecursiveAction() {
1061	–	protected void realCompute() throws Exception {
1062	–	AsyncFib f = new AsyncFib(8);
1063	–	assertSame(f, f.fork());
1064	–	try {
1065	–	f.get(5L, null);
1066	–	shouldThrow();
1067	–	} catch (NullPointerException success) {}
1068	–	}};
1069	–	testInvokeOnPool(singletonPool(), a);
1070	–	}
1071	–
1072	–	/**
1073	–	* quietlyJoin of a forked task returns when task completes
1074	–	*/
1075	–	public void testForkQuietlyJoinSingleton() {
1076	–	RecursiveAction a = new CheckedRecursiveAction() {
1077	–	protected void realCompute() {
1078	–	AsyncFib f = new AsyncFib(8);
1079	–	assertSame(f, f.fork());
1080	–	f.quietlyJoin();
1081	–	assertEquals(21, f.number);
1082	–	checkCompletedNormally(f);
1083	–	}};
1084	–	testInvokeOnPool(singletonPool(), a);
1085	–	}
1086	–
1087	–	/**
1088	–	* helpQuiesce returns when tasks are complete.
1089	–	* getQueuedTaskCount returns 0 when quiescent
1090	–	*/
1091	–	public void testForkHelpQuiesceSingleton() {
1092	–	RecursiveAction a = new CheckedRecursiveAction() {
1093	–	protected void realCompute() {
1094	–	AsyncFib f = new AsyncFib(8);
1095	–	assertSame(f, f.fork());
1096	–	helpQuiesce();
1097	–	assertEquals(0, getQueuedTaskCount());
1098	–	assertEquals(21, f.number);
1099	–	checkCompletedNormally(f);
1100	–	}};
1101	–	testInvokeOnPool(singletonPool(), a);
1102	–	}
1103	–
1104	–	/**
1105	–	* invoke task throws exception when task completes abnormally
1106	–	*/
1107	–	public void testAbnormalInvokeSingleton() {
1108	–	RecursiveAction a = new CheckedRecursiveAction() {
1109	–	protected void realCompute() {
1110	–	FailingAsyncFib f = new FailingAsyncFib(8);
1111	–	try {
1112	–	f.invoke();
1113	–	shouldThrow();
1114	–	} catch (FJException success) {
1115	–	checkCompletedAbnormally(f, success);
1116	–	}
1117	–	}};
1118	–	testInvokeOnPool(singletonPool(), a);
1119	–	}
1120	–
1121	–	/**
1122	–	* quietlyInvoke task returns when task completes abnormally
1123	–	*/
1124	–	public void testAbnormalQuietlyInvokeSingleton() {
1125	–	RecursiveAction a = new CheckedRecursiveAction() {
1126	–	protected void realCompute() {
1127	–	FailingAsyncFib f = new FailingAsyncFib(8);
1128	–	f.quietlyInvoke();
1129	–	assertTrue(f.getException() instanceof FJException);
1130	–	checkCompletedAbnormally(f, f.getException());
1131	–	}};
1132	–	testInvokeOnPool(singletonPool(), a);
1133	–	}
1134	–
1135	–	/**
1136	–	* join of a forked task throws exception when task completes abnormally
1137	–	*/
1138	–	public void testAbnormalForkJoinSingleton() {
1139	–	RecursiveAction a = new CheckedRecursiveAction() {
1140	–	protected void realCompute() {
1141	–	FailingAsyncFib f = new FailingAsyncFib(8);
1142	–	assertSame(f, f.fork());
1143	–	try {
1144	–	f.join();
1145	–	shouldThrow();
1146	–	} catch (FJException success) {
1147	–	checkCompletedAbnormally(f, success);
1148	–	}
1149	–	}};
1150	–	testInvokeOnPool(singletonPool(), a);
1151	–	}
1152	–
1153	–	/**
1154	–	* get of a forked task throws exception when task completes abnormally
1155	–	*/
1156	–	public void testAbnormalForkGetSingleton() {
1157	–	RecursiveAction a = new CheckedRecursiveAction() {
1158	–	protected void realCompute() throws Exception {
1159	–	FailingAsyncFib f = new FailingAsyncFib(8);
1160	–	assertSame(f, f.fork());
1161	–	try {
1162	–	f.get();
1163	–	shouldThrow();
1164	–	} catch (ExecutionException success) {
1165	–	Throwable cause = success.getCause();
1166	–	assertTrue(cause instanceof FJException);
1167	–	checkCompletedAbnormally(f, cause);
1168	–	}
1169	–	}};
1170	–	testInvokeOnPool(singletonPool(), a);
1171	–	}
1172	–
1173	–	/**
1174	–	* timed get of a forked task throws exception when task completes abnormally
1175	–	*/
1176	–	public void testAbnormalForkTimedGetSingleton() {
1177	–	RecursiveAction a = new CheckedRecursiveAction() {
1178	–	protected void realCompute() throws Exception {
1179	–	FailingAsyncFib f = new FailingAsyncFib(8);
1180	–	assertSame(f, f.fork());
1181	–	try {
1182	–	f.get(LONG_DELAY_MS, MILLISECONDS);
1183	–	shouldThrow();
1184	–	} catch (ExecutionException success) {
1185	–	Throwable cause = success.getCause();
1186	–	assertTrue(cause instanceof FJException);
1187	–	checkCompletedAbnormally(f, cause);
1188	–	}
1189	–	}};
1190	–	testInvokeOnPool(singletonPool(), a);
1191	–	}
1192	–
1193	–	/**
1194	–	* quietlyJoin of a forked task returns when task completes abnormally
1195	–	*/
1196	–	public void testAbnormalForkQuietlyJoinSingleton() {
1197	–	RecursiveAction a = new CheckedRecursiveAction() {
1198	–	protected void realCompute() {
1199	–	FailingAsyncFib f = new FailingAsyncFib(8);
1200	–	assertSame(f, f.fork());
1201	–	f.quietlyJoin();
1202	–	assertTrue(f.getException() instanceof FJException);
1203	–	checkCompletedAbnormally(f, f.getException());
1204	–	}};
1205	–	testInvokeOnPool(singletonPool(), a);
1206	–	}
1207	–
1208	–	/**
1209	–	* invoke task throws exception after invoking completeExceptionally
1210	–	*/
1211	–	public void testCompleteExceptionallySingleton() {
1212	–	RecursiveAction a = new CheckedRecursiveAction() {
1213	–	protected void realCompute() {
1214	–	AsyncFib f = new AsyncFib(8);
1215	–	f.completeExceptionally(new FJException());
1216	–	try {
1217	–	f.invoke();
1218	–	shouldThrow();
1219	–	} catch (FJException success) {
1220	–	checkCompletedAbnormally(f, success);
1221	–	}
1222	–	}};
1223	–	testInvokeOnPool(singletonPool(), a);
1224	–	}
1225	–
1226	–	/**
1227	–	* invokeAll(t1, t2) invokes all task arguments
1228	–	*/
1229	–	public void testInvokeAll2Singleton() {
1230	–	RecursiveAction a = new CheckedRecursiveAction() {
1231	–	protected void realCompute() {
1232	–	AsyncFib f = new AsyncFib(8);
1233	–	AsyncFib g = new AsyncFib(9);
1234	–	invokeAll(f, g);
1235	–	assertEquals(21, f.number);
1236	–	assertEquals(34, g.number);
1237	–	checkCompletedNormally(f);
1238	–	checkCompletedNormally(g);
1239	–	}};
1240	–	testInvokeOnPool(singletonPool(), a);
1241	–	}
1242	–
1243	–	/**
1244	–	* invokeAll(tasks) with 1 argument invokes task
1245	–	*/
1246	–	public void testInvokeAll1Singleton() {
1247	–	RecursiveAction a = new CheckedRecursiveAction() {
1248	–	protected void realCompute() {
1249	–	AsyncFib f = new AsyncFib(8);
1250	–	invokeAll(f);
1251	–	checkCompletedNormally(f);
1252	–	assertEquals(21, f.number);
1253	–	}};
1254	–	testInvokeOnPool(singletonPool(), a);
1255	–	}
1256	–
1257	–	/**
1258	–	* invokeAll(tasks) with > 2 argument invokes tasks
1259	–	*/
1260	–	public void testInvokeAll3Singleton() {
1261	–	RecursiveAction a = new CheckedRecursiveAction() {
1262	–	protected void realCompute() {
1263	–	AsyncFib f = new AsyncFib(8);
1264	–	AsyncFib g = new AsyncFib(9);
1265	–	AsyncFib h = new AsyncFib(7);
1266	–	invokeAll(f, g, h);
1267	–	assertEquals(21, f.number);
1268	–	assertEquals(34, g.number);
1269	–	assertEquals(13, h.number);
1270	–	checkCompletedNormally(f);
1271	–	checkCompletedNormally(g);
1272	–	checkCompletedNormally(h);
1273	–	}};
1274	–	testInvokeOnPool(singletonPool(), a);
1275	–	}
1276	–
1277	–	/**
1278	–	* invokeAll(collection) invokes all tasks in the collection
1279	–	*/
1280	–	public void testInvokeAllCollectionSingleton() {
1281	–	RecursiveAction a = new CheckedRecursiveAction() {
1282	–	protected void realCompute() {
1283	–	AsyncFib f = new AsyncFib(8);
1284	–	AsyncFib g = new AsyncFib(9);
1285	–	AsyncFib h = new AsyncFib(7);
1286	–	HashSet set = new HashSet();
1287	–	set.add(f);
1288	–	set.add(g);
1289	–	set.add(h);
1290	–	invokeAll(set);
1291	–	assertEquals(21, f.number);
1292	–	assertEquals(34, g.number);
1293	–	assertEquals(13, h.number);
1294	–	checkCompletedNormally(f);
1295	–	checkCompletedNormally(g);
1296	–	checkCompletedNormally(h);
1297	–	}};
1298	–	testInvokeOnPool(singletonPool(), a);
1299	–	}
1300	–
1301	–	/**
1302	–	* invokeAll(tasks) with any null task throws NPE
1303	–	*/
1304	–	public void testInvokeAllNPESingleton() {
1305	–	RecursiveAction a = new CheckedRecursiveAction() {
1306	–	protected void realCompute() {
1307	–	AsyncFib f = new AsyncFib(8);
1308	–	AsyncFib g = new AsyncFib(9);
1309	–	AsyncFib h = null;
1310	–	try {
1311	–	invokeAll(f, g, h);
1312	–	shouldThrow();
1313	–	} catch (NullPointerException success) {}
1314	–	}};
1315	–	testInvokeOnPool(singletonPool(), a);
1316	–	}
1317	–
1318	–	/**
1319	–	* invokeAll(t1, t2) throw exception if any task does
1320	–	*/
1321	–	public void testAbnormalInvokeAll2Singleton() {
1322	–	RecursiveAction a = new CheckedRecursiveAction() {
1323	–	protected void realCompute() {
1324	–	AsyncFib f = new AsyncFib(8);
1325	–	FailingAsyncFib g = new FailingAsyncFib(9);
1326	–	try {
1327	–	invokeAll(f, g);
1328	–	shouldThrow();
1329	–	} catch (FJException success) {
1330	–	checkCompletedAbnormally(g, success);
1331	–	}
1332	–	}};
1333	–	testInvokeOnPool(singletonPool(), a);
1334	–	}
1335	–
1336	–	/**
1337	–	* invokeAll(tasks) with 1 argument throws exception if task does
1338	–	*/
1339	–	public void testAbnormalInvokeAll1Singleton() {
1340	–	RecursiveAction a = new CheckedRecursiveAction() {
1341	–	protected void realCompute() {
1342	–	FailingAsyncFib g = new FailingAsyncFib(9);
1343	–	try {
1344	–	invokeAll(g);
1345	–	shouldThrow();
1346	–	} catch (FJException success) {
1347	–	checkCompletedAbnormally(g, success);
1348	–	}
1349	–	}};
1350	–	testInvokeOnPool(singletonPool(), a);
1351	–	}
1352	–
1353	–	/**
1354	–	* invokeAll(tasks) with > 2 argument throws exception if any task does
1355	–	*/
1356	–	public void testAbnormalInvokeAll3Singleton() {
1357	–	RecursiveAction a = new CheckedRecursiveAction() {
1358	–	protected void realCompute() {
1359	–	AsyncFib f = new AsyncFib(8);
1360	–	FailingAsyncFib g = new FailingAsyncFib(9);
1361	–	AsyncFib h = new AsyncFib(7);
1362	–	try {
1363	–	invokeAll(f, g, h);
1364	–	shouldThrow();
1365	–	} catch (FJException success) {
1366	–	checkCompletedAbnormally(g, success);
1367	–	}
1368	–	}};
1369	–	testInvokeOnPool(singletonPool(), a);
1370	–	}
1371	–
1372	–	/**
1373	–	* invokeAll(collection)  throws exception if any task does
1374	–	*/
1375	–	public void testAbnormalInvokeAllCollectionSingleton() {
1376	–	RecursiveAction a = new CheckedRecursiveAction() {
1377	–	protected void realCompute() {
1378	–	FailingAsyncFib f = new FailingAsyncFib(8);
1379	–	AsyncFib g = new AsyncFib(9);
1380	–	AsyncFib h = new AsyncFib(7);
1381	–	HashSet set = new HashSet();
1382	–	set.add(f);
1383	–	set.add(g);
1384	–	set.add(h);
1385	–	try {
1386	–	invokeAll(set);
1387	–	shouldThrow();
1388	–	} catch (FJException success) {
1389	–	checkCompletedAbnormally(f, success);
1390	–	}
1391	–	}};
1392	–	testInvokeOnPool(singletonPool(), a);
1393	–	}
1394	–
1144		/**
1145		* ForkJoinTask.quietlyComplete returns when task completes
1146		* normally without setting a value. The most recent value
#	Line 1413 | Line 1162 | public class ForkJoinTask8Test extends J
1162		testInvokeOnPool(mainPool(), a);
1163		}
1164
1165	+	// jdk9
1166	+
1167	+	/**
1168	+	* pollSubmission returns unexecuted submitted task, if present
1169	+	*/
1170	+	public void testPollSubmission() {
1171	+	final CountDownLatch done = new CountDownLatch(1);
1172	+	final ForkJoinTask a = ForkJoinTask.adapt(awaiter(done));
1173	+	final ForkJoinTask b = ForkJoinTask.adapt(awaiter(done));
1174	+	final ForkJoinTask c = ForkJoinTask.adapt(awaiter(done));
1175	+	final ForkJoinPool p = singletonPool();
1176	+	try (PoolCleaner cleaner = cleaner(p, done)) {
1177	+	Thread external = new Thread(new CheckedRunnable() {
1178	+	public void realRun() {
1179	+	p.execute(a);
1180	+	p.execute(b);
1181	+	p.execute(c);
1182	+	}});
1183	+	RecursiveAction s = new CheckedRecursiveAction() {
1184	+	protected void realCompute() {
1185	+	external.start();
1186	+	try {
1187	+	external.join();
1188	+	} catch (Exception ex) {
1189	+	threadUnexpectedException(ex);
1190	+	}
1191	+	assertTrue(p.hasQueuedSubmissions());
1192	+	assertTrue(Thread.currentThread() instanceof ForkJoinWorkerThread);
1193	+	ForkJoinTask r = ForkJoinTask.pollSubmission();
1194	+	assertTrue(r == a || r == b || r == c);
1195	+	assertFalse(r.isDone());
1196	+	}};
1197	+	p.invoke(s);
1198	+	}
1199	+	}
1200	+
1201		}

Diff Legend

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