ViewVC Help

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

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

Comparing jsr166/src/test/tck/ForkJoinPool8Test.java (file contents):
Revision 1.4 by dl, Thu Mar 21 19:06:54 2013 UTC vs.
Revision 1.41 by dl, Tue Jan 26 13:33:06 2021 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9	>	import java.util.HashSet;
10		import java.util.concurrent.CancellationException;
11	+	import java.util.concurrent.CountedCompleter;
12		import java.util.concurrent.ExecutionException;
13		import java.util.concurrent.ForkJoinPool;
14		import java.util.concurrent.ForkJoinTask;
12	–	import java.util.concurrent.ForkJoinWorkerThread;
15		import java.util.concurrent.RecursiveAction;
14	–	import java.util.concurrent.CountedCompleter;
15	–	import java.util.concurrent.ThreadLocalRandom;
16	–	import java.util.concurrent.TimeUnit;
16		import java.util.concurrent.TimeoutException;
17	<	import static java.util.concurrent.TimeUnit.SECONDS;
18	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
19	<	import java.util.Arrays;
21	<	import java.util.HashSet;
17	>
18	>	import junit.framework.Test;
19	>	import junit.framework.TestSuite;
20
21		public class ForkJoinPool8Test extends JSR166TestCase {
22		public static void main(String[] args) {
23	<	junit.textui.TestRunner.run(suite());
23	>	main(suite(), args);
24		}
25
26		public static Test suite() {
#	Line 59 | Line 57 | public class ForkJoinPool8Test extends J
57		* RecursiveAction and CountedCompleter, but with all actions
58		* executed in the common pool, generally implicitly via
59		* checkInvoke.
60	<	*/
60	>	*/
61
62	<	private void checkInvoke(ForkJoinTask a) {
62	>	private void checkInvoke(ForkJoinTask<?> a) {
63		checkNotDone(a);
64		assertNull(a.invoke());
65		checkCompletedNormally(a);
66		}
67
68	<	void checkNotDone(ForkJoinTask a) {
68	>	void checkNotDone(ForkJoinTask<?> a) {
69		assertFalse(a.isDone());
70		assertFalse(a.isCompletedNormally());
71		assertFalse(a.isCompletedAbnormally());
#	Line 85 | Line 83 | public class ForkJoinPool8Test extends J
83
84		Thread.currentThread().interrupt();
85		try {
86	<	a.get(5L, SECONDS);
86	>	a.get(randomTimeout(), randomTimeUnit());
87		shouldThrow();
88		} catch (InterruptedException success) {
89		} catch (Throwable fail) { threadUnexpectedException(fail); }
90		}
91
92		try {
93	<	a.get(0L, SECONDS);
93	>	a.get(randomExpiredTimeout(), randomTimeUnit());
94		shouldThrow();
95		} catch (TimeoutException success) {
96		} catch (Throwable fail) { threadUnexpectedException(fail); }
97		}
98
99	<	void checkCompletedNormally(ForkJoinTask a) {
99	>	void checkCompletedNormally(ForkJoinTask<?> a) {
100		assertTrue(a.isDone());
101		assertFalse(a.isCancelled());
102		assertTrue(a.isCompletedNormally());
#	Line 108 | Line 106 | public class ForkJoinPool8Test extends J
106		assertNull(a.join());
107		assertFalse(a.cancel(false));
108		assertFalse(a.cancel(true));
109	+
110	+	Object v1 = null, v2 = null;
111		try {
112	<	assertNull(a.get());
113	<	} catch (Throwable fail) { threadUnexpectedException(fail); }
114	<	try {
115	<	assertNull(a.get(5L, SECONDS));
112	>	v1 = a.get();
113	>	v2 = a.get(randomTimeout(), randomTimeUnit());
114		} catch (Throwable fail) { threadUnexpectedException(fail); }
115	+	assertNull(v1);
116	+	assertNull(v2);
117		}
118
119	<	void checkCancelled(ForkJoinTask a) {
119	>	void checkCancelled(ForkJoinTask<?> a) {
120		assertTrue(a.isDone());
121		assertTrue(a.isCancelled());
122		assertFalse(a.isCompletedNormally());
#	Line 137 | Line 137 | public class ForkJoinPool8Test extends J
137		} catch (Throwable fail) { threadUnexpectedException(fail); }
138
139		try {
140	<	a.get(5L, SECONDS);
140	>	a.get(randomTimeout(), randomTimeUnit());
141		shouldThrow();
142		} catch (CancellationException success) {
143		} catch (Throwable fail) { threadUnexpectedException(fail); }
144		}
145
146	<	void checkCompletedAbnormally(ForkJoinTask a, Throwable t) {
146	>	void checkCompletedAbnormally(ForkJoinTask<?> a, Throwable t) {
147		assertTrue(a.isDone());
148		assertFalse(a.isCancelled());
149		assertFalse(a.isCompletedNormally());
#	Line 168 | Line 168 | public class ForkJoinPool8Test extends J
168		} catch (Throwable fail) { threadUnexpectedException(fail); }
169
170		try {
171	<	a.get(5L, SECONDS);
171	>	a.get(randomTimeout(), randomTimeUnit());
172		shouldThrow();
173		} catch (ExecutionException success) {
174		assertSame(t.getClass(), success.getCause().getClass());
#	Line 180 | Line 180 | public class ForkJoinPool8Test extends J
180		public FJException(Throwable cause) { super(cause); }
181		}
182
183	<	// A simple recursive action for testing
183	>	/** A simple recursive action for testing. */
184		final class FibAction extends CheckedRecursiveAction {
185		final int number;
186		int result;
187		FibAction(int n) { number = n; }
188	<	public void realCompute() {
188	>	protected void realCompute() {
189		int n = number;
190		if (n <= 1)
191		result = n;
#	Line 198 | Line 198 | public class ForkJoinPool8Test extends J
198		}
199		}
200
201	<	// A recursive action failing in base case
201	>	/** A recursive action failing in base case. */
202		static final class FailingFibAction extends RecursiveAction {
203		final int number;
204		int result;
#	Line 223 | Line 223 | public class ForkJoinPool8Test extends J
223		*/
224		public void testInvoke() {
225		RecursiveAction a = new CheckedRecursiveAction() {
226	<	public void realCompute() {
226	>	protected void realCompute() {
227		FibAction f = new FibAction(8);
228		assertNull(f.invoke());
229		assertEquals(21, f.result);
#	Line 239 | Line 239 | public class ForkJoinPool8Test extends J
239		*/
240		public void testQuietlyInvoke() {
241		RecursiveAction a = new CheckedRecursiveAction() {
242	<	public void realCompute() {
242	>	protected void realCompute() {
243		FibAction f = new FibAction(8);
244		f.quietlyInvoke();
245		assertEquals(21, f.result);
#	Line 253 | Line 253 | public class ForkJoinPool8Test extends J
253		*/
254		public void testForkJoin() {
255		RecursiveAction a = new CheckedRecursiveAction() {
256	<	public void realCompute() {
256	>	protected void realCompute() {
257		FibAction f = new FibAction(8);
258		assertSame(f, f.fork());
259		assertNull(f.join());
#	Line 268 | Line 268 | public class ForkJoinPool8Test extends J
268		*/
269		public void testJoinIgnoresInterrupts() {
270		RecursiveAction a = new CheckedRecursiveAction() {
271	<	public void realCompute() {
271	>	protected void realCompute() {
272		FibAction f = new FibAction(8);
273	<	final Thread myself = Thread.currentThread();
273	>	final Thread currentThread = Thread.currentThread();
274
275		// test join()
276		assertSame(f, f.fork());
277	<	myself.interrupt();
278	<	assertTrue(myself.isInterrupted());
277	>	currentThread.interrupt();
278		assertNull(f.join());
279		Thread.interrupted();
280		assertEquals(21, f.result);
#	Line 284 | Line 283 | public class ForkJoinPool8Test extends J
283		f = new FibAction(8);
284		f.cancel(true);
285		assertSame(f, f.fork());
286	<	myself.interrupt();
288	<	assertTrue(myself.isInterrupted());
286	>	currentThread.interrupt();
287		try {
288		f.join();
289		shouldThrow();
#	Line 297 | Line 295 | public class ForkJoinPool8Test extends J
295		f = new FibAction(8);
296		f.completeExceptionally(new FJException());
297		assertSame(f, f.fork());
298	<	myself.interrupt();
301	<	assertTrue(myself.isInterrupted());
298	>	currentThread.interrupt();
299		try {
300		f.join();
301		shouldThrow();
#	Line 310 | Line 307 | public class ForkJoinPool8Test extends J
307		// test quietlyJoin()
308		f = new FibAction(8);
309		assertSame(f, f.fork());
310	<	myself.interrupt();
314	<	assertTrue(myself.isInterrupted());
310	>	currentThread.interrupt();
311		f.quietlyJoin();
312		Thread.interrupted();
313		assertEquals(21, f.result);
#	Line 320 | Line 316 | public class ForkJoinPool8Test extends J
316		f = new FibAction(8);
317		f.cancel(true);
318		assertSame(f, f.fork());
319	<	myself.interrupt();
324	<	assertTrue(myself.isInterrupted());
319	>	currentThread.interrupt();
320		f.quietlyJoin();
321		Thread.interrupted();
322		checkCancelled(f);
#	Line 329 | Line 324 | public class ForkJoinPool8Test extends J
324		f = new FibAction(8);
325		f.completeExceptionally(new FJException());
326		assertSame(f, f.fork());
327	<	myself.interrupt();
333	<	assertTrue(myself.isInterrupted());
327	>	currentThread.interrupt();
328		f.quietlyJoin();
329		Thread.interrupted();
330		checkCompletedAbnormally(f, f.getException());
#	Line 340 | Line 334 | public class ForkJoinPool8Test extends J
334		checkInvoke(a);
335		}
336
343	–
337		/**
338		* get of a forked task returns when task completes
339		*/
340		public void testForkGet() {
341		RecursiveAction a = new CheckedRecursiveAction() {
342	<	public void realCompute() throws Exception {
342	>	protected void realCompute() throws Exception {
343		FibAction f = new FibAction(8);
344		assertSame(f, f.fork());
345		assertNull(f.get());
#	Line 361 | Line 354 | public class ForkJoinPool8Test extends J
354		*/
355		public void testForkTimedGet() {
356		RecursiveAction a = new CheckedRecursiveAction() {
357	<	public void realCompute() throws Exception {
357	>	protected void realCompute() throws Exception {
358		FibAction f = new FibAction(8);
359		assertSame(f, f.fork());
360	<	assertNull(f.get(5L, SECONDS));
360	>	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
361		assertEquals(21, f.result);
362		checkCompletedNormally(f);
363		}};
#	Line 376 | Line 369 | public class ForkJoinPool8Test extends J
369		*/
370		public void testForkTimedGetNPE() {
371		RecursiveAction a = new CheckedRecursiveAction() {
372	<	public void realCompute() throws Exception {
372	>	protected void realCompute() throws Exception {
373		FibAction f = new FibAction(8);
374		assertSame(f, f.fork());
375		try {
376	<	f.get(5L, null);
376	>	f.get(randomTimeout(), null);
377		shouldThrow();
378		} catch (NullPointerException success) {}
379		}};
#	Line 392 | Line 385 | public class ForkJoinPool8Test extends J
385		*/
386		public void testForkQuietlyJoin() {
387		RecursiveAction a = new CheckedRecursiveAction() {
388	<	public void realCompute() {
388	>	protected void realCompute() {
389		FibAction f = new FibAction(8);
390		assertSame(f, f.fork());
391		f.quietlyJoin();
#	Line 403 | Line 396 | public class ForkJoinPool8Test extends J
396		}
397
398		/**
406	–	* helpQuiesce returns when tasks are complete.
407	–	* getQueuedTaskCount returns 0 when quiescent
408	–	*/
409	–	public void testForkHelpQuiesce() {
410	–	RecursiveAction a = new CheckedRecursiveAction() {
411	–	public void realCompute() {
412	–	FibAction f = new FibAction(8);
413	–	assertSame(f, f.fork());
414	–	helpQuiesce();
415	–	assertEquals(21, f.result);
416	–	assertEquals(0, getQueuedTaskCount());
417	–	checkCompletedNormally(f);
418	–	}};
419	–	checkInvoke(a);
420	–	}
421	–
422	–	/**
399		* invoke task throws exception when task completes abnormally
400		*/
401		public void testAbnormalInvoke() {
402		RecursiveAction a = new CheckedRecursiveAction() {
403	<	public void realCompute() {
403	>	protected void realCompute() {
404		FailingFibAction f = new FailingFibAction(8);
405		try {
406		f.invoke();
#	Line 441 | Line 417 | public class ForkJoinPool8Test extends J
417		*/
418		public void testAbnormalQuietlyInvoke() {
419		RecursiveAction a = new CheckedRecursiveAction() {
420	<	public void realCompute() {
420	>	protected void realCompute() {
421		FailingFibAction f = new FailingFibAction(8);
422		f.quietlyInvoke();
423		assertTrue(f.getException() instanceof FJException);
#	Line 455 | Line 431 | public class ForkJoinPool8Test extends J
431		*/
432		public void testAbnormalForkJoin() {
433		RecursiveAction a = new CheckedRecursiveAction() {
434	<	public void realCompute() {
434	>	protected void realCompute() {
435		FailingFibAction f = new FailingFibAction(8);
436		assertSame(f, f.fork());
437		try {
#	Line 473 | Line 449 | public class ForkJoinPool8Test extends J
449		*/
450		public void testAbnormalForkGet() {
451		RecursiveAction a = new CheckedRecursiveAction() {
452	<	public void realCompute() throws Exception {
452	>	protected void realCompute() throws Exception {
453		FailingFibAction f = new FailingFibAction(8);
454		assertSame(f, f.fork());
455		try {
#	Line 493 | Line 469 | public class ForkJoinPool8Test extends J
469		*/
470		public void testAbnormalForkTimedGet() {
471		RecursiveAction a = new CheckedRecursiveAction() {
472	<	public void realCompute() throws Exception {
472	>	protected void realCompute() throws Exception {
473		FailingFibAction f = new FailingFibAction(8);
474		assertSame(f, f.fork());
475		try {
476	<	f.get(5L, TimeUnit.SECONDS);
476	>	f.get(LONG_DELAY_MS, MILLISECONDS);
477		shouldThrow();
478		} catch (ExecutionException success) {
479		Throwable cause = success.getCause();
#	Line 513 | Line 489 | public class ForkJoinPool8Test extends J
489		*/
490		public void testAbnormalForkQuietlyJoin() {
491		RecursiveAction a = new CheckedRecursiveAction() {
492	<	public void realCompute() {
492	>	protected void realCompute() {
493		FailingFibAction f = new FailingFibAction(8);
494		assertSame(f, f.fork());
495		f.quietlyJoin();
#	Line 528 | Line 504 | public class ForkJoinPool8Test extends J
504		*/
505		public void testCancelledInvoke() {
506		RecursiveAction a = new CheckedRecursiveAction() {
507	<	public void realCompute() {
507	>	protected void realCompute() {
508		FibAction f = new FibAction(8);
509		assertTrue(f.cancel(true));
510		try {
#	Line 546 | Line 522 | public class ForkJoinPool8Test extends J
522		*/
523		public void testCancelledForkJoin() {
524		RecursiveAction a = new CheckedRecursiveAction() {
525	<	public void realCompute() {
525	>	protected void realCompute() {
526		FibAction f = new FibAction(8);
527		assertTrue(f.cancel(true));
528		assertSame(f, f.fork());
#	Line 565 | Line 541 | public class ForkJoinPool8Test extends J
541		*/
542		public void testCancelledForkGet() {
543		RecursiveAction a = new CheckedRecursiveAction() {
544	<	public void realCompute() throws Exception {
544	>	protected void realCompute() throws Exception {
545		FibAction f = new FibAction(8);
546		assertTrue(f.cancel(true));
547		assertSame(f, f.fork());
#	Line 584 | Line 560 | public class ForkJoinPool8Test extends J
560		*/
561		public void testCancelledForkTimedGet() {
562		RecursiveAction a = new CheckedRecursiveAction() {
563	<	public void realCompute() throws Exception {
563	>	protected void realCompute() throws Exception {
564		FibAction f = new FibAction(8);
565		assertTrue(f.cancel(true));
566		assertSame(f, f.fork());
567		try {
568	<	f.get(5L, SECONDS);
568	>	f.get(LONG_DELAY_MS, MILLISECONDS);
569		shouldThrow();
570		} catch (CancellationException success) {
571		checkCancelled(f);
#	Line 603 | Line 579 | public class ForkJoinPool8Test extends J
579		*/
580		public void testCancelledForkQuietlyJoin() {
581		RecursiveAction a = new CheckedRecursiveAction() {
582	<	public void realCompute() {
582	>	protected void realCompute() {
583		FibAction f = new FibAction(8);
584		assertTrue(f.cancel(true));
585		assertSame(f, f.fork());
#	Line 618 | Line 594 | public class ForkJoinPool8Test extends J
594		*/
595		public void testInForkJoinPool2() {
596		RecursiveAction a = new CheckedRecursiveAction() {
597	<	public void realCompute() {
597	>	protected void realCompute() {
598		assertFalse(inForkJoinPool());
599		}};
600		assertNull(a.invoke());
#	Line 629 | Line 605 | public class ForkJoinPool8Test extends J
605		*/
606		public void testReinitialize() {
607		RecursiveAction a = new CheckedRecursiveAction() {
608	<	public void realCompute() {
608	>	protected void realCompute() {
609		FibAction f = new FibAction(8);
610		checkNotDone(f);
611
#	Line 649 | Line 625 | public class ForkJoinPool8Test extends J
625		*/
626		public void testReinitializeAbnormal() {
627		RecursiveAction a = new CheckedRecursiveAction() {
628	<	public void realCompute() {
628	>	protected void realCompute() {
629		FailingFibAction f = new FailingFibAction(8);
630		checkNotDone(f);
631
#	Line 672 | Line 648 | public class ForkJoinPool8Test extends J
648		*/
649		public void testCompleteExceptionally() {
650		RecursiveAction a = new CheckedRecursiveAction() {
651	<	public void realCompute() {
651	>	protected void realCompute() {
652		FibAction f = new FibAction(8);
653		f.completeExceptionally(new FJException());
654		try {
#	Line 690 | Line 666 | public class ForkJoinPool8Test extends J
666		*/
667		public void testComplete() {
668		RecursiveAction a = new CheckedRecursiveAction() {
669	<	public void realCompute() {
669	>	protected void realCompute() {
670		FibAction f = new FibAction(8);
671		f.complete(null);
672		assertNull(f.invoke());
#	Line 705 | Line 681 | public class ForkJoinPool8Test extends J
681		*/
682		public void testInvokeAll2() {
683		RecursiveAction a = new CheckedRecursiveAction() {
684	<	public void realCompute() {
684	>	protected void realCompute() {
685		FibAction f = new FibAction(8);
686		FibAction g = new FibAction(9);
687		invokeAll(f, g);
#	Line 722 | Line 698 | public class ForkJoinPool8Test extends J
698		*/
699		public void testInvokeAll1() {
700		RecursiveAction a = new CheckedRecursiveAction() {
701	<	public void realCompute() {
701	>	protected void realCompute() {
702		FibAction f = new FibAction(8);
703		invokeAll(f);
704		checkCompletedNormally(f);
#	Line 736 | Line 712 | public class ForkJoinPool8Test extends J
712		*/
713		public void testInvokeAll3() {
714		RecursiveAction a = new CheckedRecursiveAction() {
715	<	public void realCompute() {
715	>	protected void realCompute() {
716		FibAction f = new FibAction(8);
717		FibAction g = new FibAction(9);
718		FibAction h = new FibAction(7);
#	Line 759 | Line 735 | public class ForkJoinPool8Test extends J
735		*/
736		public void testInvokeAllCollection() {
737		RecursiveAction a = new CheckedRecursiveAction() {
738	<	public void realCompute() {
738	>	protected void realCompute() {
739		FibAction f = new FibAction(8);
740		FibAction g = new FibAction(9);
741		FibAction h = new FibAction(7);
742	<	HashSet set = new HashSet();
742	>	HashSet<ForkJoinTask<?>> set = new HashSet<ForkJoinTask<?>>();
743		set.add(f);
744		set.add(g);
745		set.add(h);
#	Line 786 | Line 762 | public class ForkJoinPool8Test extends J
762		*/
763		public void testInvokeAllNPE() {
764		RecursiveAction a = new CheckedRecursiveAction() {
765	<	public void realCompute() {
765	>	protected void realCompute() {
766		FibAction f = new FibAction(8);
767		FibAction g = new FibAction(9);
768		FibAction h = null;
#	Line 803 | Line 779 | public class ForkJoinPool8Test extends J
779		*/
780		public void testAbnormalInvokeAll2() {
781		RecursiveAction a = new CheckedRecursiveAction() {
782	<	public void realCompute() {
782	>	protected void realCompute() {
783		FibAction f = new FibAction(8);
784		FailingFibAction g = new FailingFibAction(9);
785		try {
#	Line 821 | Line 797 | public class ForkJoinPool8Test extends J
797		*/
798		public void testAbnormalInvokeAll1() {
799		RecursiveAction a = new CheckedRecursiveAction() {
800	<	public void realCompute() {
800	>	protected void realCompute() {
801		FailingFibAction g = new FailingFibAction(9);
802		try {
803		invokeAll(g);
#	Line 838 | Line 814 | public class ForkJoinPool8Test extends J
814		*/
815		public void testAbnormalInvokeAll3() {
816		RecursiveAction a = new CheckedRecursiveAction() {
817	<	public void realCompute() {
817	>	protected void realCompute() {
818		FibAction f = new FibAction(8);
819		FailingFibAction g = new FailingFibAction(9);
820		FibAction h = new FibAction(7);
#	Line 857 | Line 833 | public class ForkJoinPool8Test extends J
833		*/
834		public void testAbnormalInvokeAllCollection() {
835		RecursiveAction a = new CheckedRecursiveAction() {
836	<	public void realCompute() {
836	>	protected void realCompute() {
837		FailingFibAction f = new FailingFibAction(8);
838		FibAction g = new FibAction(9);
839		FibAction h = new FibAction(7);
840	<	HashSet set = new HashSet();
840	>	HashSet<ForkJoinTask<?>> set = new HashSet<ForkJoinTask<?>>();
841		set.add(f);
842		set.add(g);
843		set.add(h);
#	Line 877 | Line 853 | public class ForkJoinPool8Test extends J
853
854		// CountedCompleter versions
855
856	<	public abstract class CheckedFJTask extends RecursiveAction {
881	<	protected abstract void realCompute() throws Throwable;
882	<
883	<	public final void compute() {
884	<	try {
885	<	realCompute();
886	<	} catch (Throwable t) {
887	<	threadUnexpectedException(t);
888	<	}
889	<	}
890	<	}
891	<
892	<	static abstract class CCF extends CountedCompleter {
856	>	abstract static class CCF extends CountedCompleter<Void> {
857		int number;
858		int rnumber;
859
860	<	public CCF(CountedCompleter parent, int n) {
860	>	public CCF(CountedCompleter<?> parent, int n) {
861		super(parent, 1);
862		this.number = n;
863		}
864
865		public final void compute() {
866	<	CountedCompleter p;
866	>	CountedCompleter<?> p;
867		CCF f = this;
868		int n = number;
869		while (n >= 2) {
#	Line 910 | Line 874 | public class ForkJoinPool8Test extends J
874		f.onCompletion(f);
875		if ((p = f.getCompleter()) != null)
876		p.tryComplete();
877	<	else
878	<	f.quietlyComplete();
877	>	else
878	>	f.quietlyComplete();
879		}
880		}
881
882		static final class LCCF extends CCF {
883	<	public LCCF(CountedCompleter parent, int n) {
883	>	public LCCF(CountedCompleter<?> parent, int n) {
884		super(parent, n);
885		}
886	<	public final void onCompletion(CountedCompleter caller) {
886	>	public final void onCompletion(CountedCompleter<?> caller) {
887		CCF p = (CCF)getCompleter();
888		int n = number + rnumber;
889		if (p != null)
#	Line 932 | Line 896 | public class ForkJoinPool8Test extends J
896		public RCCF(CountedCompleter parent, int n) {
897		super(parent, n);
898		}
899	<	public final void onCompletion(CountedCompleter caller) {
899	>	public final void onCompletion(CountedCompleter<?> caller) {
900		CCF p = (CCF)getCompleter();
901		int n = number + rnumber;
902		if (p != null)
#	Line 942 | Line 906 | public class ForkJoinPool8Test extends J
906		}
907		}
908
909	<	// Version of CCF with forced failure in left completions
910	<	static abstract class FailingCCF extends CountedCompleter {
909	>	/** Version of CCF with forced failure in left completions. */
910	>	abstract static class FailingCCF extends CountedCompleter<Void> {
911		int number;
912		int rnumber;
913
914	<	public FailingCCF(CountedCompleter parent, int n) {
914	>	public FailingCCF(CountedCompleter<?> parent, int n) {
915		super(parent, 1);
916		this.number = n;
917		}
918
919		public final void compute() {
920	<	CountedCompleter p;
920	>	CountedCompleter<?> p;
921		FailingCCF f = this;
922		int n = number;
923		while (n >= 2) {
#	Line 964 | Line 928 | public class ForkJoinPool8Test extends J
928		f.onCompletion(f);
929		if ((p = f.getCompleter()) != null)
930		p.tryComplete();
931	<	else
932	<	f.quietlyComplete();
931	>	else
932	>	f.quietlyComplete();
933		}
934		}
935
936		static final class LFCCF extends FailingCCF {
937	<	public LFCCF(CountedCompleter parent, int n) {
937	>	public LFCCF(CountedCompleter<?> parent, int n) {
938		super(parent, n);
939		}
940	<	public final void onCompletion(CountedCompleter caller) {
940	>	public final void onCompletion(CountedCompleter<?> caller) {
941		FailingCCF p = (FailingCCF)getCompleter();
942		int n = number + rnumber;
943		if (p != null)
#	Line 983 | Line 947 | public class ForkJoinPool8Test extends J
947		}
948		}
949		static final class RFCCF extends FailingCCF {
950	<	public RFCCF(CountedCompleter parent, int n) {
950	>	public RFCCF(CountedCompleter<?> parent, int n) {
951		super(parent, n);
952		}
953	<	public final void onCompletion(CountedCompleter caller) {
953	>	public final void onCompletion(CountedCompleter<?> caller) {
954		completeExceptionally(new FJException());
955		}
956		}
957	<
957	>
958		/**
959		* invoke returns when task completes normally.
960		* isCompletedAbnormally and isCancelled return false for normally
961		* completed tasks; getRawResult returns null.
962		*/
963		public void testInvokeCC() {
964	<	ForkJoinTask a =  new CheckedFJTask() {
965	<	public void realCompute() {
964	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
965	>	protected void realCompute() {
966		CCF f = new LCCF(null, 8);
967		assertNull(f.invoke());
968		assertEquals(21, f.number);
#	Line 1013 | Line 977 | public class ForkJoinPool8Test extends J
977		* completed tasks
978		*/
979		public void testQuietlyInvokeCC() {
980	<	ForkJoinTask a =  new CheckedFJTask() {
981	<	public void realCompute() {
980	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
981	>	protected void realCompute() {
982		CCF f = new LCCF(null, 8);
983		f.quietlyInvoke();
984		assertEquals(21, f.number);
#	Line 1027 | Line 991 | public class ForkJoinPool8Test extends J
991		* join of a forked task returns when task completes
992		*/
993		public void testForkJoinCC() {
994	<	ForkJoinTask a =  new CheckedFJTask() {
995	<	public void realCompute() {
994	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
995	>	protected void realCompute() {
996		CCF f = new LCCF(null, 8);
997		assertSame(f, f.fork());
998		assertNull(f.join());
#	Line 1042 | Line 1006 | public class ForkJoinPool8Test extends J
1006		* get of a forked task returns when task completes
1007		*/
1008		public void testForkGetCC() {
1009	<	ForkJoinTask a =  new CheckedFJTask() {
1010	<	public void realCompute() throws Exception {
1009	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1010	>	protected void realCompute() throws Exception {
1011		CCF f = new LCCF(null, 8);
1012		assertSame(f, f.fork());
1013		assertNull(f.get());
#	Line 1057 | Line 1021 | public class ForkJoinPool8Test extends J
1021		* timed get of a forked task returns when task completes
1022		*/
1023		public void testForkTimedGetCC() {
1024	<	ForkJoinTask a =  new CheckedFJTask() {
1025	<	public void realCompute() throws Exception {
1024	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1025	>	protected void realCompute() throws Exception {
1026		CCF f = new LCCF(null, 8);
1027		assertSame(f, f.fork());
1028		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
#	Line 1072 | Line 1036 | public class ForkJoinPool8Test extends J
1036		* timed get with null time unit throws NPE
1037		*/
1038		public void testForkTimedGetNPECC() {
1039	<	ForkJoinTask a =  new CheckedFJTask() {
1040	<	public void realCompute() throws Exception {
1039	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1040	>	protected void realCompute() throws Exception {
1041		CCF f = new LCCF(null, 8);
1042		assertSame(f, f.fork());
1043		try {
1044	<	f.get(5L, null);
1044	>	f.get(randomTimeout(), null);
1045		shouldThrow();
1046		} catch (NullPointerException success) {}
1047		}};
#	Line 1088 | Line 1052 | public class ForkJoinPool8Test extends J
1052		* quietlyJoin of a forked task returns when task completes
1053		*/
1054		public void testForkQuietlyJoinCC() {
1055	<	ForkJoinTask a =  new CheckedFJTask() {
1056	<	public void realCompute() {
1055	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1056	>	protected void realCompute() {
1057		CCF f = new LCCF(null, 8);
1058		assertSame(f, f.fork());
1059		f.quietlyJoin();
#	Line 1100 | Line 1064 | public class ForkJoinPool8Test extends J
1064		}
1065
1066		/**
1103	–	* helpQuiesce returns when tasks are complete.
1104	–	* getQueuedTaskCount returns 0 when quiescent
1105	–	*/
1106	–	public void testForkHelpQuiesceCC() {
1107	–	ForkJoinTask a =  new CheckedFJTask() {
1108	–	public void realCompute() {
1109	–	CCF f = new LCCF(null, 8);
1110	–	assertSame(f, f.fork());
1111	–	helpQuiesce();
1112	–	assertEquals(21, f.number);
1113	–	assertEquals(0, getQueuedTaskCount());
1114	–	checkCompletedNormally(f);
1115	–	}};
1116	–	checkInvoke(a);
1117	–	}
1118	–
1119	–	/**
1067		* invoke task throws exception when task completes abnormally
1068		*/
1069		public void testAbnormalInvokeCC() {
1070	<	ForkJoinTask a =  new CheckedFJTask() {
1071	<	public void realCompute() {
1070	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1071	>	protected void realCompute() {
1072		FailingCCF f = new LFCCF(null, 8);
1073		try {
1074		f.invoke();
#	Line 1137 | Line 1084 | public class ForkJoinPool8Test extends J
1084		* quietlyInvoke task returns when task completes abnormally
1085		*/
1086		public void testAbnormalQuietlyInvokeCC() {
1087	<	ForkJoinTask a =  new CheckedFJTask() {
1088	<	public void realCompute() {
1087	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1088	>	protected void realCompute() {
1089		FailingCCF f = new LFCCF(null, 8);
1090		f.quietlyInvoke();
1091		assertTrue(f.getException() instanceof FJException);
#	Line 1151 | Line 1098 | public class ForkJoinPool8Test extends J
1098		* join of a forked task throws exception when task completes abnormally
1099		*/
1100		public void testAbnormalForkJoinCC() {
1101	<	ForkJoinTask a =  new CheckedFJTask() {
1102	<	public void realCompute() {
1101	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1102	>	protected void realCompute() {
1103		FailingCCF f = new LFCCF(null, 8);
1104		assertSame(f, f.fork());
1105		try {
#	Line 1169 | Line 1116 | public class ForkJoinPool8Test extends J
1116		* get of a forked task throws exception when task completes abnormally
1117		*/
1118		public void testAbnormalForkGetCC() {
1119	<	ForkJoinTask a =  new CheckedFJTask() {
1120	<	public void realCompute() throws Exception {
1119	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1120	>	protected void realCompute() throws Exception {
1121		FailingCCF f = new LFCCF(null, 8);
1122		assertSame(f, f.fork());
1123		try {
#	Line 1189 | Line 1136 | public class ForkJoinPool8Test extends J
1136		* timed get of a forked task throws exception when task completes abnormally
1137		*/
1138		public void testAbnormalForkTimedGetCC() {
1139	<	ForkJoinTask a =  new CheckedFJTask() {
1140	<	public void realCompute() throws Exception {
1139	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1140	>	protected void realCompute() throws Exception {
1141		FailingCCF f = new LFCCF(null, 8);
1142		assertSame(f, f.fork());
1143		try {
#	Line 1209 | Line 1156 | public class ForkJoinPool8Test extends J
1156		* quietlyJoin of a forked task returns when task completes abnormally
1157		*/
1158		public void testAbnormalForkQuietlyJoinCC() {
1159	<	ForkJoinTask a =  new CheckedFJTask() {
1160	<	public void realCompute() {
1159	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1160	>	protected void realCompute() {
1161		FailingCCF f = new LFCCF(null, 8);
1162		assertSame(f, f.fork());
1163		f.quietlyJoin();
#	Line 1224 | Line 1171 | public class ForkJoinPool8Test extends J
1171		* invoke task throws exception when task cancelled
1172		*/
1173		public void testCancelledInvokeCC() {
1174	<	ForkJoinTask a =  new CheckedFJTask() {
1175	<	public void realCompute() {
1174	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1175	>	protected void realCompute() {
1176		CCF f = new LCCF(null, 8);
1177		assertTrue(f.cancel(true));
1178		try {
#	Line 1242 | Line 1189 | public class ForkJoinPool8Test extends J
1189		* join of a forked task throws exception when task cancelled
1190		*/
1191		public void testCancelledForkJoinCC() {
1192	<	ForkJoinTask a =  new CheckedFJTask() {
1193	<	public void realCompute() {
1192	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1193	>	protected void realCompute() {
1194		CCF f = new LCCF(null, 8);
1195		assertTrue(f.cancel(true));
1196		assertSame(f, f.fork());
#	Line 1261 | Line 1208 | public class ForkJoinPool8Test extends J
1208		* get of a forked task throws exception when task cancelled
1209		*/
1210		public void testCancelledForkGetCC() {
1211	<	ForkJoinTask a =  new CheckedFJTask() {
1212	<	public void realCompute() throws Exception {
1211	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1212	>	protected void realCompute() throws Exception {
1213		CCF f = new LCCF(null, 8);
1214		assertTrue(f.cancel(true));
1215		assertSame(f, f.fork());
#	Line 1280 | Line 1227 | public class ForkJoinPool8Test extends J
1227		* timed get of a forked task throws exception when task cancelled
1228		*/
1229		public void testCancelledForkTimedGetCC() throws Exception {
1230	<	ForkJoinTask a =  new CheckedFJTask() {
1231	<	public void realCompute() throws Exception {
1230	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1231	>	protected void realCompute() throws Exception {
1232		CCF f = new LCCF(null, 8);
1233		assertTrue(f.cancel(true));
1234		assertSame(f, f.fork());
#	Line 1299 | Line 1246 | public class ForkJoinPool8Test extends J
1246		* quietlyJoin of a forked task returns when task cancelled
1247		*/
1248		public void testCancelledForkQuietlyJoinCC() {
1249	<	ForkJoinTask a =  new CheckedFJTask() {
1250	<	public void realCompute() {
1249	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1250	>	protected void realCompute() {
1251		CCF f = new LCCF(null, 8);
1252		assertTrue(f.cancel(true));
1253		assertSame(f, f.fork());
#	Line 1314 | Line 1261 | public class ForkJoinPool8Test extends J
1261		* getPool of non-FJ task returns null
1262		*/
1263		public void testGetPool2CC() {
1264	<	ForkJoinTask a =  new CheckedFJTask() {
1265	<	public void realCompute() {
1264	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1265	>	protected void realCompute() {
1266		assertNull(getPool());
1267		}};
1268		assertNull(a.invoke());
#	Line 1325 | Line 1272 | public class ForkJoinPool8Test extends J
1272		* inForkJoinPool of non-FJ task returns false
1273		*/
1274		public void testInForkJoinPool2CC() {
1275	<	ForkJoinTask a =  new CheckedFJTask() {
1276	<	public void realCompute() {
1275	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1276	>	protected void realCompute() {
1277		assertFalse(inForkJoinPool());
1278		}};
1279		assertNull(a.invoke());
#	Line 1336 | Line 1283 | public class ForkJoinPool8Test extends J
1283		* setRawResult(null) succeeds
1284		*/
1285		public void testSetRawResultCC() {
1286	<	ForkJoinTask a =  new CheckedFJTask() {
1287	<	public void realCompute() {
1286	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1287	>	protected void realCompute() {
1288		setRawResult(null);
1289		assertNull(getRawResult());
1290		}};
#	Line 1348 | Line 1295 | public class ForkJoinPool8Test extends J
1295		* invoke task throws exception after invoking completeExceptionally
1296		*/
1297		public void testCompleteExceptionally2CC() {
1298	<	ForkJoinTask a =  new CheckedFJTask() {
1299	<	public void realCompute() {
1298	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1299	>	protected void realCompute() {
1300		CCF f = new LCCF(null, 8);
1301		f.completeExceptionally(new FJException());
1302		try {
#	Line 1366 | Line 1313 | public class ForkJoinPool8Test extends J
1313		* invokeAll(t1, t2) invokes all task arguments
1314		*/
1315		public void testInvokeAll2CC() {
1316	<	ForkJoinTask a =  new CheckedFJTask() {
1317	<	public void realCompute() {
1316	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1317	>	protected void realCompute() {
1318		CCF f = new LCCF(null, 8);
1319		CCF g = new LCCF(null, 9);
1320		invokeAll(f, g);
#	Line 1383 | Line 1330 | public class ForkJoinPool8Test extends J
1330		* invokeAll(tasks) with 1 argument invokes task
1331		*/
1332		public void testInvokeAll1CC() {
1333	<	ForkJoinTask a =  new CheckedFJTask() {
1334	<	public void realCompute() {
1333	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1334	>	protected void realCompute() {
1335		CCF f = new LCCF(null, 8);
1336		invokeAll(f);
1337		checkCompletedNormally(f);
#	Line 1397 | Line 1344 | public class ForkJoinPool8Test extends J
1344		* invokeAll(tasks) with > 2 argument invokes tasks
1345		*/
1346		public void testInvokeAll3CC() {
1347	<	ForkJoinTask a =  new CheckedFJTask() {
1348	<	public void realCompute() {
1347	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1348	>	protected void realCompute() {
1349		CCF f = new LCCF(null, 8);
1350		CCF g = new LCCF(null, 9);
1351		CCF h = new LCCF(null, 7);
#	Line 1417 | Line 1364 | public class ForkJoinPool8Test extends J
1364		* invokeAll(collection) invokes all tasks in the collection
1365		*/
1366		public void testInvokeAllCollectionCC() {
1367	<	ForkJoinTask a =  new CheckedFJTask() {
1368	<	public void realCompute() {
1367	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1368	>	protected void realCompute() {
1369		CCF f = new LCCF(null, 8);
1370		CCF g = new LCCF(null, 9);
1371		CCF h = new LCCF(null, 7);
1372	<	HashSet set = new HashSet();
1372	>	HashSet<ForkJoinTask<?>> set = new HashSet<ForkJoinTask<?>>();
1373		set.add(f);
1374		set.add(g);
1375		set.add(h);
#	Line 1441 | Line 1388 | public class ForkJoinPool8Test extends J
1388		* invokeAll(tasks) with any null task throws NPE
1389		*/
1390		public void testInvokeAllNPECC() {
1391	<	ForkJoinTask a =  new CheckedFJTask() {
1392	<	public void realCompute() {
1391	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1392	>	protected void realCompute() {
1393		CCF f = new LCCF(null, 8);
1394		CCF g = new LCCF(null, 9);
1395		CCF h = null;
#	Line 1458 | Line 1405 | public class ForkJoinPool8Test extends J
1405		* invokeAll(t1, t2) throw exception if any task does
1406		*/
1407		public void testAbnormalInvokeAll2CC() {
1408	<	ForkJoinTask a =  new CheckedFJTask() {
1409	<	public void realCompute() {
1408	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1409	>	protected void realCompute() {
1410		CCF f = new LCCF(null, 8);
1411		FailingCCF g = new LFCCF(null, 9);
1412		try {
#	Line 1476 | Line 1423 | public class ForkJoinPool8Test extends J
1423		* invokeAll(tasks) with 1 argument throws exception if task does
1424		*/
1425		public void testAbnormalInvokeAll1CC() {
1426	<	ForkJoinTask a =  new CheckedFJTask() {
1427	<	public void realCompute() {
1426	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1427	>	protected void realCompute() {
1428		FailingCCF g = new LFCCF(null, 9);
1429		try {
1430		invokeAll(g);
#	Line 1493 | Line 1440 | public class ForkJoinPool8Test extends J
1440		* invokeAll(tasks) with > 2 argument throws exception if any task does
1441		*/
1442		public void testAbnormalInvokeAll3CC() {
1443	<	ForkJoinTask a =  new CheckedFJTask() {
1444	<	public void realCompute() {
1443	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1444	>	protected void realCompute() {
1445		CCF f = new LCCF(null, 8);
1446		FailingCCF g = new LFCCF(null, 9);
1447		CCF h = new LCCF(null, 7);
#	Line 1509 | Line 1456 | public class ForkJoinPool8Test extends J
1456		}
1457
1458		/**
1459	<	* invokeAll(collection)  throws exception if any task does
1459	>	* invokeAll(collection) throws exception if any task does
1460		*/
1461		public void testAbnormalInvokeAllCollectionCC() {
1462	<	ForkJoinTask a =  new CheckedFJTask() {
1463	<	public void realCompute() {
1462	>	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1463	>	protected void realCompute() {
1464		FailingCCF f = new LFCCF(null, 8);
1465		CCF g = new LCCF(null, 9);
1466		CCF h = new LCCF(null, 7);
1467	<	HashSet set = new HashSet();
1467	>	HashSet<ForkJoinTask<?>> set = new HashSet<ForkJoinTask<?>>();
1468		set.add(f);
1469		set.add(g);
1470		set.add(h);
#	Line 1531 | Line 1478 | public class ForkJoinPool8Test extends J
1478		checkInvoke(a);
1479		}
1480
1481	+	/**
1482	+	* awaitQuiescence by a worker is equivalent in effect to
1483	+	* ForkJoinTask.helpQuiesce()
1484	+	*/
1485	+	public void testAwaitQuiescence1() throws Exception {
1486	+	final ForkJoinPool p = new ForkJoinPool();
1487	+	try (PoolCleaner cleaner = cleaner(p)) {
1488	+	final long startTime = System.nanoTime();
1489	+	assertTrue(p.isQuiescent());
1490	+	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1491	+	protected void realCompute() {
1492	+	FibAction f = new FibAction(8);
1493	+	assertSame(f, f.fork());
1494	+	assertSame(p, ForkJoinTask.getPool());
1495	+	boolean quiescent = p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS);
1496	+	assertTrue(quiescent);
1497	+	assertFalse(p.isQuiescent());
1498	+	while (!f.isDone()) {
1499	+	assertFalse(p.getAsyncMode());
1500	+	assertFalse(p.isShutdown());
1501	+	assertFalse(p.isTerminating());
1502	+	assertFalse(p.isTerminated());
1503	+	Thread.yield();
1504	+	}
1505	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1506	+	assertFalse(p.isQuiescent());
1507	+	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1508	+	assertEquals(21, f.result);
1509	+	}};
1510	+	p.execute(a);
1511	+	while (!a.isDone() || !p.isQuiescent()) {
1512	+	assertFalse(p.getAsyncMode());
1513	+	assertFalse(p.isShutdown());
1514	+	assertFalse(p.isTerminating());
1515	+	assertFalse(p.isTerminated());
1516	+	Thread.yield();
1517	+	}
1518	+	assertEquals(0, p.getQueuedTaskCount());
1519	+	assertFalse(p.getAsyncMode());
1520	+	assertEquals(0, p.getQueuedSubmissionCount());
1521	+	assertFalse(p.hasQueuedSubmissions());
1522	+	while (p.getActiveThreadCount() != 0
1523	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1524	+	Thread.yield();
1525	+	assertFalse(p.isShutdown());
1526	+	assertFalse(p.isTerminating());
1527	+	assertFalse(p.isTerminated());
1528	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1529	+	}
1530	+	}
1531	+
1532	+	/**
1533	+	* awaitQuiescence returns when pool isQuiescent() or the indicated
1534	+	* timeout elapsed
1535	+	*/
1536	+	public void testAwaitQuiescence2() throws Exception {
1537	+	/*
1538	+	* """It is possible to disable or limit the use of threads in the
1539	+	* common pool by setting the parallelism property to zero. However
1540	+	* doing so may cause unjoined tasks to never be executed."""
1541	+	*/
1542	+	if ("0".equals(System.getProperty(
1543	+	"java.util.concurrent.ForkJoinPool.common.parallelism")))
1544	+	return;
1545	+	final ForkJoinPool p = new ForkJoinPool();
1546	+	try (PoolCleaner cleaner = cleaner(p)) {
1547	+	assertTrue(p.isQuiescent());
1548	+	final long startTime = System.nanoTime();
1549	+	CheckedRecursiveAction a = new CheckedRecursiveAction() {
1550	+	protected void realCompute() {
1551	+	FibAction f = new FibAction(8);
1552	+	assertSame(f, f.fork());
1553	+	while (!f.isDone()
1554	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS) {
1555	+	assertFalse(p.getAsyncMode());
1556	+	assertFalse(p.isShutdown());
1557	+	assertFalse(p.isTerminating());
1558	+	assertFalse(p.isTerminated());
1559	+	Thread.yield();
1560	+	}
1561	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1562	+	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1563	+	assertEquals(21, f.result);
1564	+	}};
1565	+	p.execute(a);
1566	+	assertTrue(p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS));
1567	+	assertTrue(p.isQuiescent());
1568	+	assertTrue(a.isDone());
1569	+	assertEquals(0, p.getQueuedTaskCount());
1570	+	assertFalse(p.getAsyncMode());
1571	+	assertEquals(0, p.getQueuedSubmissionCount());
1572	+	assertFalse(p.hasQueuedSubmissions());
1573	+	while (p.getActiveThreadCount() != 0
1574	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1575	+	Thread.yield();
1576	+	assertFalse(p.isShutdown());
1577	+	assertFalse(p.isTerminating());
1578	+	assertFalse(p.isTerminated());
1579	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1580	+	}
1581	+	}
1582	+
1583		}

Diff Legend

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