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

Diff Legend

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