ViewVC Help

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

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

Comparing jsr166/src/test/tck/RecursiveTaskTest.java (file contents):
Revision 1.19 by jsr166, Thu Sep 16 00:52:49 2010 UTC vs.
Revision 1.39 by jsr166, Sun Jul 22 21:13:32 2018 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
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.ExecutionException;
12		import java.util.concurrent.ForkJoinPool;
13	+	import java.util.concurrent.ForkJoinTask;
14		import java.util.concurrent.RecursiveTask;
15	<	import java.util.concurrent.TimeUnit;
16	<	import java.util.HashSet;
15	>	import java.util.concurrent.TimeoutException;
16	>
17	>	import junit.framework.Test;
18	>	import junit.framework.TestSuite;
19
20		public class RecursiveTaskTest extends JSR166TestCase {
21
22		public static void main(String[] args) {
23	<	junit.textui.TestRunner.run(suite());
23	>	main(suite(), args);
24		}
25		public static Test suite() {
26		return new TestSuite(RecursiveTaskTest.class);
#	Line 36 | Line 41 | public class RecursiveTaskTest extends J
41		}
42
43		private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
44	<	try {
45	<	assertFalse(a.isDone());
41	<	assertFalse(a.isCompletedNormally());
42	<	assertFalse(a.isCompletedAbnormally());
43	<	assertFalse(a.isCancelled());
44	>	try (PoolCleaner cleaner = cleaner(pool)) {
45	>	checkNotDone(a);
46
47		T result = pool.invoke(a);
48
49	<	assertTrue(a.isDone());
48	<	assertTrue(a.isCompletedNormally());
49	<	assertFalse(a.isCompletedAbnormally());
50	<	assertFalse(a.isCancelled());
51	<	assertNull(a.getException());
49	>	checkCompletedNormally(a, result);
50		return result;
53	–	} finally {
54	–	joinPool(pool);
51		}
52		}
53
54	<	static final class FJException extends RuntimeException {
55	<	FJException() { super(); }
54	>	void checkNotDone(RecursiveTask a) {
55	>	assertFalse(a.isDone());
56	>	assertFalse(a.isCompletedNormally());
57	>	assertFalse(a.isCompletedAbnormally());
58	>	assertFalse(a.isCancelled());
59	>	assertNull(a.getException());
60	>	assertNull(a.getRawResult());
61	>
62	>	if (! ForkJoinTask.inForkJoinPool()) {
63	>	Thread.currentThread().interrupt();
64	>	try {
65	>	a.get();
66	>	shouldThrow();
67	>	} catch (InterruptedException success) {
68	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
69	>
70	>	Thread.currentThread().interrupt();
71	>	try {
72	>	a.get(randomTimeout(), randomTimeUnit());
73	>	shouldThrow();
74	>	} catch (InterruptedException success) {
75	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
76	>	}
77	>
78	>	try {
79	>	a.get(randomExpiredTimeout(), randomTimeUnit());
80	>	shouldThrow();
81	>	} catch (TimeoutException success) {
82	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
83	>	}
84	>
85	>	<T> void checkCompletedNormally(RecursiveTask<T> a, T expectedValue) {
86	>	assertTrue(a.isDone());
87	>	assertFalse(a.isCancelled());
88	>	assertTrue(a.isCompletedNormally());
89	>	assertFalse(a.isCompletedAbnormally());
90	>	assertNull(a.getException());
91	>	assertSame(expectedValue, a.getRawResult());
92	>	assertSame(expectedValue, a.join());
93	>	assertFalse(a.cancel(false));
94	>	assertFalse(a.cancel(true));
95	>
96	>	T v1 = null, v2 = null;
97	>	try {
98	>	v1 = a.get();
99	>	v2 = a.get(randomTimeout(), randomTimeUnit());
100	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
101	>	assertSame(expectedValue, v1);
102	>	assertSame(expectedValue, v2);
103	>	}
104	>
105	>	/**
106	>	* Waits for the task to complete, and checks that when it does,
107	>	* it will have an Integer result equals to the given int.
108	>	*/
109	>	void checkCompletesNormally(RecursiveTask<Integer> a, int expectedValue) {
110	>	Integer r = a.join();
111	>	assertEquals(expectedValue, (int) r);
112	>	checkCompletedNormally(a, r);
113	>	}
114	>
115	>	/**
116	>	* Like checkCompletesNormally, but verifies that the task has
117	>	* already completed.
118	>	*/
119	>	void checkCompletedNormally(RecursiveTask<Integer> a, int expectedValue) {
120	>	Integer r = a.getRawResult();
121	>	assertEquals(expectedValue, (int) r);
122	>	checkCompletedNormally(a, r);
123	>	}
124	>
125	>	void checkCancelled(RecursiveTask a) {
126	>	assertTrue(a.isDone());
127	>	assertTrue(a.isCancelled());
128	>	assertFalse(a.isCompletedNormally());
129	>	assertTrue(a.isCompletedAbnormally());
130	>	assertTrue(a.getException() instanceof CancellationException);
131	>	assertNull(a.getRawResult());
132	>
133	>	try {
134	>	a.join();
135	>	shouldThrow();
136	>	} catch (CancellationException success) {
137	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
138	>
139	>	try {
140	>	a.get();
141	>	shouldThrow();
142	>	} catch (CancellationException success) {
143	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
144	>
145	>	try {
146	>	a.get(randomTimeout(), randomTimeUnit());
147	>	shouldThrow();
148	>	} catch (CancellationException success) {
149	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
150	>	}
151	>
152	>	void checkCompletedAbnormally(RecursiveTask a, Throwable t) {
153	>	assertTrue(a.isDone());
154	>	assertFalse(a.isCancelled());
155	>	assertFalse(a.isCompletedNormally());
156	>	assertTrue(a.isCompletedAbnormally());
157	>	assertSame(t.getClass(), a.getException().getClass());
158	>	assertNull(a.getRawResult());
159	>	assertFalse(a.cancel(false));
160	>	assertFalse(a.cancel(true));
161	>
162	>	try {
163	>	a.join();
164	>	shouldThrow();
165	>	} catch (Throwable expected) {
166	>	assertSame(t.getClass(), expected.getClass());
167	>	}
168	>
169	>	try {
170	>	a.get();
171	>	shouldThrow();
172	>	} catch (ExecutionException success) {
173	>	assertSame(t.getClass(), success.getCause().getClass());
174	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
175	>
176	>	try {
177	>	a.get(randomTimeout(), randomTimeUnit());
178	>	shouldThrow();
179	>	} catch (ExecutionException success) {
180	>	assertSame(t.getClass(), success.getCause().getClass());
181	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
182	>	}
183	>
184	>	public static final class FJException extends RuntimeException {
185	>	public FJException() { super(); }
186		}
187
188	<	// An invalid return value for Fib
188	>	/** An invalid return value for Fib. */
189		static final Integer NoResult = Integer.valueOf(-17);
190
191	<	// A simple recursive task for testing
191	>	/** A simple recursive task for testing. */
192		final class FibTask extends CheckedRecursiveTask<Integer> {
193		final int number;
194		FibTask(int n) { number = n; }
#	Line 74 | Line 200 | public class RecursiveTaskTest extends J
200		f1.fork();
201		return (new FibTask(n - 2)).compute() + f1.join();
202		}
203	+
204	+	public void publicSetRawResult(Integer result) {
205	+	setRawResult(result);
206	+	}
207		}
208
209	<	// A recursive action failing in base case
209	>	/** A recursive action failing in base case. */
210		final class FailingFibTask extends RecursiveTask<Integer> {
211		final int number;
212		int result;
#	Line 103 | Line 233 | public class RecursiveTaskTest extends J
233		FibTask f = new FibTask(8);
234		Integer r = f.invoke();
235		assertEquals(21, (int) r);
236	<	assertTrue(f.isDone());
107	<	assertFalse(f.isCancelled());
108	<	assertFalse(f.isCompletedAbnormally());
109	<	assertEquals(21, (int) f.getRawResult());
236	>	checkCompletedNormally(f, r);
237		return r;
238		}};
239		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
#	Line 122 | Line 249 | public class RecursiveTaskTest extends J
249		public Integer realCompute() {
250		FibTask f = new FibTask(8);
251		f.quietlyInvoke();
252	<	Integer r = f.getRawResult();
253	<	assertEquals(21, (int) r);
127	<	assertTrue(f.isDone());
128	<	assertFalse(f.isCancelled());
129	<	assertFalse(f.isCompletedAbnormally());
130	<	return r;
252	>	checkCompletedNormally(f, 21);
253	>	return NoResult;
254		}};
255	<	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
255	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
256		}
257
258		/**
#	Line 142 | Line 265 | public class RecursiveTaskTest extends J
265		assertSame(f, f.fork());
266		Integer r = f.join();
267		assertEquals(21, (int) r);
268	<	assertTrue(f.isDone());
268	>	checkCompletedNormally(f, r);
269		return r;
270		}};
271		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
#	Line 158 | Line 281 | public class RecursiveTaskTest extends J
281		assertSame(f, f.fork());
282		Integer r = f.get();
283		assertEquals(21, (int) r);
284	<	assertTrue(f.isDone());
284	>	checkCompletedNormally(f, r);
285		return r;
286		}};
287		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
#	Line 172 | Line 295 | public class RecursiveTaskTest extends J
295		public Integer realCompute() throws Exception {
296		FibTask f = new FibTask(8);
297		assertSame(f, f.fork());
298	<	Integer r = f.get(5L, TimeUnit.SECONDS);
298	>	Integer r = f.get(LONG_DELAY_MS, MILLISECONDS);
299		assertEquals(21, (int) r);
300	<	assertTrue(f.isDone());
300	>	checkCompletedNormally(f, r);
301		return r;
302		}};
303		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
#	Line 191 | Line 314 | public class RecursiveTaskTest extends J
314		f.quietlyJoin();
315		Integer r = f.getRawResult();
316		assertEquals(21, (int) r);
317	<	assertTrue(f.isDone());
317	>	checkCompletedNormally(f, r);
318		return r;
319		}};
320		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
321		}
322
200	–
323		/**
324		* helpQuiesce returns when tasks are complete.
325		* getQueuedTaskCount returns 0 when quiescent
#	Line 207 | Line 329 | public class RecursiveTaskTest extends J
329		public Integer realCompute() {
330		FibTask f = new FibTask(8);
331		assertSame(f, f.fork());
332	<	f.helpQuiesce();
333	<	Integer r = f.getRawResult();
334	<	assertEquals(21, (int) r);
213	<	assertTrue(f.isDone());
332	>	helpQuiesce();
333	>	while (!f.isDone()) // wait out race
334	>	;
335		assertEquals(0, getQueuedTaskCount());
336	<	return r;
336	>	checkCompletedNormally(f, 21);
337	>	return NoResult;
338		}};
339	<	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
339	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
340		}
341
220	–
342		/**
343		* invoke task throws exception when task completes abnormally
344		*/
#	Line 228 | Line 349 | public class RecursiveTaskTest extends J
349		try {
350		f.invoke();
351		shouldThrow();
352	<	return NoResult;
353	<	} catch (FJException success) {}
352	>	} catch (FJException success) {
353	>	checkCompletedAbnormally(f, success);
354	>	}
355		return NoResult;
356		}};
357		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 243 | Line 365 | public class RecursiveTaskTest extends J
365		public Integer realCompute() {
366		FailingFibTask f = new FailingFibTask(8);
367		f.quietlyInvoke();
368	<	assertTrue(f.isDone());
368	>	assertTrue(f.getException() instanceof FJException);
369	>	checkCompletedAbnormally(f, f.getException());
370		return NoResult;
371		}};
372		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 260 | Line 383 | public class RecursiveTaskTest extends J
383		try {
384		Integer r = f.join();
385		shouldThrow();
386	<	return r;
387	<	} catch (FJException success) {}
386	>	} catch (FJException success) {
387	>	checkCompletedAbnormally(f, success);
388	>	}
389		return NoResult;
390		}};
391		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 278 | Line 402 | public class RecursiveTaskTest extends J
402		try {
403		Integer r = f.get();
404		shouldThrow();
405	<	return r;
406	<	} catch (ExecutionException success) {}
405	>	} catch (ExecutionException success) {
406	>	Throwable cause = success.getCause();
407	>	assertTrue(cause instanceof FJException);
408	>	checkCompletedAbnormally(f, cause);
409	>	}
410		return NoResult;
411		}};
412		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 294 | Line 421 | public class RecursiveTaskTest extends J
421		FailingFibTask f = new FailingFibTask(8);
422		assertSame(f, f.fork());
423		try {
424	<	Integer r = f.get(5L, TimeUnit.SECONDS);
424	>	Integer r = f.get(LONG_DELAY_MS, MILLISECONDS);
425		shouldThrow();
426	<	return r;
427	<	} catch (ExecutionException success) {}
426	>	} catch (ExecutionException success) {
427	>	Throwable cause = success.getCause();
428	>	assertTrue(cause instanceof FJException);
429	>	checkCompletedAbnormally(f, cause);
430	>	}
431		return NoResult;
432		}};
433		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 312 | Line 442 | public class RecursiveTaskTest extends J
442		FailingFibTask f = new FailingFibTask(8);
443		assertSame(f, f.fork());
444		f.quietlyJoin();
315	–	assertTrue(f.isDone());
316	–	assertTrue(f.isCompletedAbnormally());
445		assertTrue(f.getException() instanceof FJException);
446	+	checkCompletedAbnormally(f, f.getException());
447		return NoResult;
448		}};
449		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 331 | Line 460 | public class RecursiveTaskTest extends J
460		try {
461		Integer r = f.invoke();
462		shouldThrow();
463	<	return r;
464	<	} catch (CancellationException success) {}
463	>	} catch (CancellationException success) {
464	>	checkCancelled(f);
465	>	}
466		return NoResult;
467		}};
468		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 350 | Line 480 | public class RecursiveTaskTest extends J
480		try {
481		Integer r = f.join();
482		shouldThrow();
483	<	return r;
484	<	} catch (CancellationException success) {}
483	>	} catch (CancellationException success) {
484	>	checkCancelled(f);
485	>	}
486		return NoResult;
487		}};
488		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 369 | Line 500 | public class RecursiveTaskTest extends J
500		try {
501		Integer r = f.get();
502		shouldThrow();
503	<	return r;
504	<	} catch (CancellationException success) {}
503	>	} catch (CancellationException success) {
504	>	checkCancelled(f);
505	>	}
506		return NoResult;
507		}};
508		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 386 | Line 518 | public class RecursiveTaskTest extends J
518		assertTrue(f.cancel(true));
519		assertSame(f, f.fork());
520		try {
521	<	Integer r = f.get(5L, TimeUnit.SECONDS);
521	>	Integer r = f.get(LONG_DELAY_MS, MILLISECONDS);
522		shouldThrow();
523	<	return r;
524	<	} catch (CancellationException success) {}
523	>	} catch (CancellationException success) {
524	>	checkCancelled(f);
525	>	}
526		return NoResult;
527		}};
528		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 405 | Line 538 | public class RecursiveTaskTest extends J
538		assertTrue(f.cancel(true));
539		assertSame(f, f.fork());
540		f.quietlyJoin();
541	<	assertTrue(f.isDone());
409	<	assertTrue(f.isCompletedAbnormally());
410	<	assertTrue(f.isCancelled());
411	<	assertTrue(f.getException() instanceof CancellationException);
541	>	checkCancelled(f);
542		return NoResult;
543		}};
544		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 457 | Line 587 | public class RecursiveTaskTest extends J
587		public void testInForkJoinPool2() {
588		RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
589		public Integer realCompute() {
590	<	assertTrue(!inForkJoinPool());
590	>	assertFalse(inForkJoinPool());
591		return NoResult;
592		}};
593		assertSame(NoResult, a.invoke());
#	Line 474 | Line 604 | public class RecursiveTaskTest extends J
604		return NoResult;
605		}
606		};
607	<	a.invoke();
607	>	assertSame(NoResult, a.invoke());
608		}
609
610		/**
611	<	* A reinitialized task may be re-invoked
611	>	* A reinitialized normally completed task may be re-invoked
612		*/
613		public void testReinitialize() {
614		RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
615		public Integer realCompute() {
616		FibTask f = new FibTask(8);
617	<	Integer r = f.invoke();
618	<	assertEquals(21, (int) r);
619	<	assertTrue(f.isDone());
620	<	assertFalse(f.isCancelled());
621	<	assertFalse(f.isCompletedAbnormally());
622	<	f.reinitialize();
623	<	r = f.invoke();
624	<	assertEquals(21, (int) r);
617	>	checkNotDone(f);
618	>
619	>	for (int i = 0; i < 3; i++) {
620	>	Integer r = f.invoke();
621	>	assertEquals(21, (int) r);
622	>	checkCompletedNormally(f, r);
623	>	f.reinitialize();
624	>	f.publicSetRawResult(null);
625	>	checkNotDone(f);
626	>	}
627	>	return NoResult;
628	>	}};
629	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
630	>	}
631	>
632	>	/**
633	>	* A reinitialized abnormally completed task may be re-invoked
634	>	*/
635	>	public void testReinitializeAbnormal() {
636	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
637	>	public Integer realCompute() {
638	>	FailingFibTask f = new FailingFibTask(8);
639	>	checkNotDone(f);
640	>
641	>	for (int i = 0; i < 3; i++) {
642	>	try {
643	>	f.invoke();
644	>	shouldThrow();
645	>	} catch (FJException success) {
646	>	checkCompletedAbnormally(f, success);
647	>	}
648	>	f.reinitialize();
649	>	checkNotDone(f);
650	>	}
651		return NoResult;
652		}};
653		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 508 | Line 664 | public class RecursiveTaskTest extends J
664		try {
665		Integer r = f.invoke();
666		shouldThrow();
667	<	return r;
668	<	} catch (FJException success) {}
667	>	} catch (FJException success) {
668	>	checkCompletedAbnormally(f, success);
669	>	}
670		return NoResult;
671		}};
672		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 524 | Line 681 | public class RecursiveTaskTest extends J
681		FibTask f = new FibTask(8);
682		f.complete(NoResult);
683		Integer r = f.invoke();
527	–	assertTrue(f.isDone());
684		assertSame(NoResult, r);
685	+	checkCompletedNormally(f, NoResult);
686		return r;
687		}};
688		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 540 | Line 697 | public class RecursiveTaskTest extends J
697		FibTask f = new FibTask(8);
698		FibTask g = new FibTask(9);
699		invokeAll(f, g);
700	<	assertTrue(f.isDone());
701	<	assertEquals(21, (int) f.join());
545	<	assertTrue(g.isDone());
546	<	assertEquals(34, (int) g.join());
700	>	checkCompletedNormally(f, 21);
701	>	checkCompletedNormally(g, 34);
702		return NoResult;
703		}};
704		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 557 | Line 712 | public class RecursiveTaskTest extends J
712		public Integer realCompute() {
713		FibTask f = new FibTask(8);
714		invokeAll(f);
715	<	assertTrue(f.isDone());
561	<	assertEquals(21, (int) f.join());
715	>	checkCompletedNormally(f, 21);
716		return NoResult;
717		}};
718		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 575 | Line 729 | public class RecursiveTaskTest extends J
729		FibTask h = new FibTask(7);
730		invokeAll(f, g, h);
731		assertTrue(f.isDone());
578	–	assertEquals(21, (int) f.join());
732		assertTrue(g.isDone());
580	–	assertEquals(34, (int) g.join());
733		assertTrue(h.isDone());
734	<	assertEquals(13, (int) h.join());
734	>	checkCompletedNormally(f, 21);
735	>	checkCompletedNormally(g, 34);
736	>	checkCompletedNormally(h, 13);
737		return NoResult;
738		}};
739		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 600 | Line 754 | public class RecursiveTaskTest extends J
754		set.add(h);
755		invokeAll(set);
756		assertTrue(f.isDone());
603	–	assertEquals(21, (int) f.join());
757		assertTrue(g.isDone());
605	–	assertEquals(34, (int) g.join());
758		assertTrue(h.isDone());
759	<	assertEquals(13, (int) h.join());
759	>	checkCompletedNormally(f, 21);
760	>	checkCompletedNormally(g, 34);
761	>	checkCompletedNormally(h, 13);
762		return NoResult;
763		}};
764		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
765		}
766
767	+	/**
768	+	* invokeAll(tasks) with any null task throws NPE
769	+	*/
770	+	public void testInvokeAllNPE() {
771	+	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
772	+	public Integer realCompute() {
773	+	FibTask f = new FibTask(8);
774	+	FibTask g = new FibTask(9);
775	+	FibTask h = null;
776	+	try {
777	+	invokeAll(f, g, h);
778	+	shouldThrow();
779	+	} catch (NullPointerException success) {}
780	+	return NoResult;
781	+	}};
782	+	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
783	+	}
784
785		/**
786		* invokeAll(t1, t2) throw exception if any task does
#	Line 622 | Line 793 | public class RecursiveTaskTest extends J
793		try {
794		invokeAll(f, g);
795		shouldThrow();
796	<	return NoResult;
797	<	} catch (FJException success) {}
796	>	} catch (FJException success) {
797	>	checkCompletedAbnormally(g, success);
798	>	}
799		return NoResult;
800		}};
801		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 639 | Line 811 | public class RecursiveTaskTest extends J
811		try {
812		invokeAll(g);
813		shouldThrow();
814	<	return NoResult;
815	<	} catch (FJException success) {}
814	>	} catch (FJException success) {
815	>	checkCompletedAbnormally(g, success);
816	>	}
817		return NoResult;
818		}};
819		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 658 | Line 831 | public class RecursiveTaskTest extends J
831		try {
832		invokeAll(f, g, h);
833		shouldThrow();
834	<	return NoResult;
835	<	} catch (FJException success) {}
834	>	} catch (FJException success) {
835	>	checkCompletedAbnormally(g, success);
836	>	}
837		return NoResult;
838		}};
839		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 681 | Line 855 | public class RecursiveTaskTest extends J
855		try {
856		invokeAll(set);
857		shouldThrow();
858	<	return NoResult;
859	<	} catch (FJException success) {}
858	>	} catch (FJException success) {
859	>	checkCompletedAbnormally(f, success);
860	>	}
861		return NoResult;
862		}};
863		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
#	Line 701 | Line 876 | public class RecursiveTaskTest extends J
876		assertSame(f, f.fork());
877		assertTrue(f.tryUnfork());
878		helpQuiesce();
879	<	assertFalse(f.isDone());
880	<	assertTrue(g.isDone());
879	>	checkNotDone(f);
880	>	checkCompletedNormally(g, 34);
881		return NoResult;
882		}};
883		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
#	Line 723 | Line 898 | public class RecursiveTaskTest extends J
898		assertSame(f, f.fork());
899		assertTrue(getSurplusQueuedTaskCount() > 0);
900		helpQuiesce();
901	+	assertEquals(0, getSurplusQueuedTaskCount());
902	+	checkCompletedNormally(f, 21);
903	+	checkCompletedNormally(g, 34);
904	+	checkCompletedNormally(h, 13);
905		return NoResult;
906		}};
907		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
#	Line 739 | Line 918 | public class RecursiveTaskTest extends J
918		FibTask f = new FibTask(8);
919		assertSame(f, f.fork());
920		assertSame(f, peekNextLocalTask());
921	<	assertEquals(21, (int) f.join());
743	<	assertTrue(f.isDone());
921	>	checkCompletesNormally(f, 21);
922		helpQuiesce();
923	+	checkCompletedNormally(g, 34);
924		return NoResult;
925		}};
926		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
#	Line 760 | Line 939 | public class RecursiveTaskTest extends J
939		assertSame(f, f.fork());
940		assertSame(f, pollNextLocalTask());
941		helpQuiesce();
942	<	assertFalse(f.isDone());
942	>	checkNotDone(f);
943	>	checkCompletedNormally(g, 34);
944		return NoResult;
945		}};
946		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
#	Line 778 | Line 958 | public class RecursiveTaskTest extends J
958		assertSame(f, f.fork());
959		assertSame(f, pollTask());
960		helpQuiesce();
961	<	assertFalse(f.isDone());
962	<	assertTrue(g.isDone());
961	>	checkNotDone(f);
962	>	checkCompletedNormally(g, 34);
963		return NoResult;
964		}};
965		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
#	Line 798 | Line 978 | public class RecursiveTaskTest extends J
978		assertSame(g, peekNextLocalTask());
979		assertEquals(21, (int) f.join());
980		helpQuiesce();
981	<	assertTrue(f.isDone());
981	>	checkCompletedNormally(f, 21);
982	>	checkCompletedNormally(g, 34);
983		return NoResult;
984		}};
985		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
986		}
987
988		/**
989	<	* pollNextLocalTask returns least recent unexecuted task
990	<	* without executing it, in async mode
989	>	* pollNextLocalTask returns least recent unexecuted task without
990	>	* executing it, in async mode
991		*/
992		public void testPollNextLocalTaskAsync() {
993		RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
#	Line 817 | Line 998 | public class RecursiveTaskTest extends J
998		assertSame(f, f.fork());
999		assertSame(g, pollNextLocalTask());
1000		helpQuiesce();
1001	<	assertTrue(f.isDone());
1002	<	assertFalse(g.isDone());
1001	>	checkCompletedNormally(f, 21);
1002	>	checkNotDone(g);
1003		return NoResult;
1004		}};
1005		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
1006		}
1007
1008		/**
1009	<	* pollTask returns an unexecuted task
1010	<	* without executing it, in async mode
1009	>	* pollTask returns an unexecuted task without executing it, in
1010	>	* async mode
1011		*/
1012		public void testPollTaskAsync() {
1013		RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
#	Line 837 | Line 1018 | public class RecursiveTaskTest extends J
1018		assertSame(f, f.fork());
1019		assertSame(g, pollTask());
1020		helpQuiesce();
1021	<	assertTrue(f.isDone());
1022	<	assertFalse(g.isDone());
1021	>	checkCompletedNormally(f, 21);
1022	>	checkNotDone(g);
1023		return NoResult;
1024		}};
1025		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));

Diff Legend

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