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.9 by dl, Wed Aug 11 19:50:02 2010 UTC vs.
Revision 1.33 by jsr166, Sun Oct 4 18:28:51 2015 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	–	import junit.framework.*;
7	–	import java.util.concurrent.*;
8	–	import java.util.*;
6
7	+	import static java.util.concurrent.TimeUnit.SECONDS;
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.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);
27		}
28
29	<	static final ForkJoinPool mainPool = new ForkJoinPool();
30	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
31	<	static final ForkJoinPool asyncSingletonPool =
32	<	new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory,
33	<	null, true);
29	>	private static ForkJoinPool mainPool() {
30	>	return new ForkJoinPool();
31	>	}
32	>
33	>	private static ForkJoinPool singletonPool() {
34	>	return new ForkJoinPool(1);
35	>	}
36
37	<	static final class FJException extends RuntimeException {
38	<	FJException() { super(); }
37	>	private static ForkJoinPool asyncSingletonPool() {
38	>	return new ForkJoinPool(1,
39	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
40	>	null, true);
41	>	}
42	>
43	>	private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
44	>	try (PoolCleaner cleaner = cleaner(pool)) {
45	>	checkNotDone(a);
46	>
47	>	T result = pool.invoke(a);
48	>
49	>	checkCompletedNormally(a, result);
50	>	return result;
51	>	}
52	>	}
53	>
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(5L, SECONDS);
73	>	shouldThrow();
74	>	} catch (InterruptedException success) {
75	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
76	>	}
77	>
78	>	try {
79	>	a.get(0L, SECONDS);
80	>	shouldThrow();
81	>	} catch (TimeoutException success) {
82	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
83	>	}
84	>
85	>	<T> void checkCompletedNormally(RecursiveTask<T> a, T expected) {
86	>	assertTrue(a.isDone());
87	>	assertFalse(a.isCancelled());
88	>	assertTrue(a.isCompletedNormally());
89	>	assertFalse(a.isCompletedAbnormally());
90	>	assertNull(a.getException());
91	>	assertSame(expected, a.getRawResult());
92	>	assertSame(expected, a.join());
93	>	assertFalse(a.cancel(false));
94	>	assertFalse(a.cancel(true));
95	>	try {
96	>	assertSame(expected, a.get());
97	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
98	>	try {
99	>	assertSame(expected, a.get(5L, SECONDS));
100	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
101	>	}
102	>
103	>	/**
104	>	* Waits for the task to complete, and checks that when it does,
105	>	* it will have an Integer result equals to the given int.
106	>	*/
107	>	void checkCompletesNormally(RecursiveTask<Integer> a, int expected) {
108	>	Integer r = a.join();
109	>	assertEquals(expected, (int) r);
110	>	checkCompletedNormally(a, r);
111	>	}
112	>
113	>	/**
114	>	* Like checkCompletesNormally, but verifies that the task has
115	>	* already completed.
116	>	*/
117	>	void checkCompletedNormally(RecursiveTask<Integer> a, int expected) {
118	>	Integer r = a.getRawResult();
119	>	assertEquals(expected, (int) r);
120	>	checkCompletedNormally(a, r);
121	>	}
122	>
123	>	void checkCancelled(RecursiveTask a) {
124	>	assertTrue(a.isDone());
125	>	assertTrue(a.isCancelled());
126	>	assertFalse(a.isCompletedNormally());
127	>	assertTrue(a.isCompletedAbnormally());
128	>	assertTrue(a.getException() instanceof CancellationException);
129	>	assertNull(a.getRawResult());
130	>
131	>	try {
132	>	a.join();
133	>	shouldThrow();
134	>	} catch (CancellationException success) {
135	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
136	>
137	>	try {
138	>	a.get();
139	>	shouldThrow();
140	>	} catch (CancellationException success) {
141	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
142	>
143	>	try {
144	>	a.get(5L, SECONDS);
145	>	shouldThrow();
146	>	} catch (CancellationException success) {
147	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
148	>	}
149	>
150	>	void checkCompletedAbnormally(RecursiveTask a, Throwable t) {
151	>	assertTrue(a.isDone());
152	>	assertFalse(a.isCancelled());
153	>	assertFalse(a.isCompletedNormally());
154	>	assertTrue(a.isCompletedAbnormally());
155	>	assertSame(t.getClass(), a.getException().getClass());
156	>	assertNull(a.getRawResult());
157	>	assertFalse(a.cancel(false));
158	>	assertFalse(a.cancel(true));
159	>
160	>	try {
161	>	a.join();
162	>	shouldThrow();
163	>	} catch (Throwable expected) {
164	>	assertSame(t.getClass(), expected.getClass());
165	>	}
166	>
167	>	try {
168	>	a.get();
169	>	shouldThrow();
170	>	} catch (ExecutionException success) {
171	>	assertSame(t.getClass(), success.getCause().getClass());
172	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
173	>
174	>	try {
175	>	a.get(5L, SECONDS);
176	>	shouldThrow();
177	>	} catch (ExecutionException success) {
178	>	assertSame(t.getClass(), success.getCause().getClass());
179	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
180	>	}
181	>
182	>	public static final class FJException extends RuntimeException {
183	>	public FJException() { super(); }
184		}
185
186		// An invalid return value for Fib
187		static final Integer NoResult = Integer.valueOf(-17);
188
189		// A simple recursive task for testing
190	<	static final class FibTask extends RecursiveTask<Integer> {
190	>	final class FibTask extends CheckedRecursiveTask<Integer> {
191		final int number;
192		FibTask(int n) { number = n; }
193	<	public Integer compute() {
193	>	public Integer realCompute() {
194		int n = number;
195		if (n <= 1)
196		return n;
#	Line 42 | Line 198 | public class RecursiveTaskTest extends J
198		f1.fork();
199		return (new FibTask(n - 2)).compute() + f1.join();
200		}
201	+
202	+	public void publicSetRawResult(Integer result) {
203	+	setRawResult(result);
204	+	}
205		}
206
207		// A recursive action failing in base case
208	<	static final class FailingFibTask extends RecursiveTask<Integer> {
208	>	final class FailingFibTask extends RecursiveTask<Integer> {
209		final int number;
210		int result;
211		FailingFibTask(int n) { number = n; }
#	Line 64 | Line 224 | public class RecursiveTaskTest extends J
224		* isCompletedAbnormally and isCancelled return false for normally
225		* completed tasks. getRawResult of a completed non-null task
226		* returns value;
67	–	*
227		*/
228		public void testInvoke() {
229	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
230	<	public Integer compute() {
229	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
230	>	public Integer realCompute() {
231		FibTask f = new FibTask(8);
232		Integer r = f.invoke();
233	<	threadAssertTrue(r == 21);
234	<	threadAssertTrue(f.isDone());
76	<	threadAssertFalse(f.isCancelled());
77	<	threadAssertFalse(f.isCompletedAbnormally());
78	<	threadAssertTrue(f.getRawResult() == 21);
233	>	assertEquals(21, (int) r);
234	>	checkCompletedNormally(f, r);
235		return r;
236	<	}
237	<	};
82	<	assertTrue(mainPool.invoke(a) == 21);
236	>	}};
237	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
238		}
239
240		/**
#	Line 88 | Line 243 | public class RecursiveTaskTest extends J
243		* completed tasks
244		*/
245		public void testQuietlyInvoke() {
246	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
247	<	public Integer compute() {
246	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
247	>	public Integer realCompute() {
248		FibTask f = new FibTask(8);
249		f.quietlyInvoke();
250	<	Integer r = f.getRawResult();
251	<	threadAssertTrue(r == 21);
252	<	threadAssertTrue(f.isDone());
253	<	threadAssertFalse(f.isCancelled());
99	<	threadAssertFalse(f.isCompletedAbnormally());
100	<	return r;
101	<	}
102	<	};
103	<	assertTrue(mainPool.invoke(a) == 21);
250	>	checkCompletedNormally(f, 21);
251	>	return NoResult;
252	>	}};
253	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
254		}
255
256		/**
257		* join of a forked task returns when task completes
258		*/
259		public void testForkJoin() {
260	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
261	<	public Integer compute() {
260	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
261	>	public Integer realCompute() {
262		FibTask f = new FibTask(8);
263	<	f.fork();
263	>	assertSame(f, f.fork());
264		Integer r = f.join();
265	<	threadAssertTrue(r == 21);
266	<	threadAssertTrue(f.isDone());
265	>	assertEquals(21, (int) r);
266	>	checkCompletedNormally(f, r);
267		return r;
268	<	}
269	<	};
120	<	assertTrue(mainPool.invoke(a) == 21);
268	>	}};
269	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
270		}
271
272		/**
273		* get of a forked task returns when task completes
274		*/
275		public void testForkGet() {
276	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
277	<	public Integer compute() {
278	<	try {
279	<	FibTask f = new FibTask(8);
280	<	f.fork();
281	<	Integer r = f.get();
282	<	threadAssertTrue(r == 21);
283	<	threadAssertTrue(f.isDone());
284	<	return r;
285	<	} catch (Exception ex) {
137	<	unexpectedException(ex);
138	<	}
139	<	return NoResult;
140	<	}
141	<	};
142	<	assertTrue(mainPool.invoke(a) == 21);
276	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
277	>	public Integer realCompute() throws Exception {
278	>	FibTask f = new FibTask(8);
279	>	assertSame(f, f.fork());
280	>	Integer r = f.get();
281	>	assertEquals(21, (int) r);
282	>	checkCompletedNormally(f, r);
283	>	return r;
284	>	}};
285	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
286		}
287
288		/**
289		* timed get of a forked task returns when task completes
290		*/
291		public void testForkTimedGet() {
292	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
293	<	public Integer compute() {
294	<	try {
295	<	FibTask f = new FibTask(8);
296	<	f.fork();
297	<	Integer r = f.get(5L, TimeUnit.SECONDS);
298	<	threadAssertTrue(r == 21);
299	<	threadAssertTrue(f.isDone());
300	<	return r;
301	<	} catch (Exception ex) {
159	<	unexpectedException(ex);
160	<	}
161	<	return NoResult;
162	<	}
163	<	};
164	<	assertTrue(mainPool.invoke(a) == 21);
292	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
293	>	public Integer realCompute() throws Exception {
294	>	FibTask f = new FibTask(8);
295	>	assertSame(f, f.fork());
296	>	Integer r = f.get(5L, SECONDS);
297	>	assertEquals(21, (int) r);
298	>	checkCompletedNormally(f, r);
299	>	return r;
300	>	}};
301	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
302		}
303
304		/**
305		* quietlyJoin of a forked task returns when task completes
306		*/
307		public void testForkQuietlyJoin() {
308	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
309	<	public Integer compute() {
308	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
309	>	public Integer realCompute() {
310		FibTask f = new FibTask(8);
311	<	f.fork();
311	>	assertSame(f, f.fork());
312		f.quietlyJoin();
313		Integer r = f.getRawResult();
314	<	threadAssertTrue(r == 21);
315	<	threadAssertTrue(f.isDone());
314	>	assertEquals(21, (int) r);
315	>	checkCompletedNormally(f, r);
316		return r;
317	<	}
318	<	};
182	<	assertTrue(mainPool.invoke(a) == 21);
317	>	}};
318	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
319		}
320
185	–
321		/**
322		* helpQuiesce returns when tasks are complete.
323		* getQueuedTaskCount returns 0 when quiescent
324		*/
325		public void testForkHelpQuiesce() {
326	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
327	<	public Integer compute() {
326	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
327	>	public Integer realCompute() {
328		FibTask f = new FibTask(8);
329	<	f.fork();
330	<	f.helpQuiesce();
331	<	Integer r = f.getRawResult();
332	<	threadAssertTrue(r == 21);
333	<	threadAssertTrue(f.isDone());
334	<	threadAssertTrue(getQueuedTaskCount() == 0);
335	<	return r;
201	<	}
202	<	};
203	<	assertTrue(mainPool.invoke(a) == 21);
329	>	assertSame(f, f.fork());
330	>	helpQuiesce();
331	>	assertEquals(0, getQueuedTaskCount());
332	>	checkCompletedNormally(f, 21);
333	>	return NoResult;
334	>	}};
335	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
336		}
337
206	–
338		/**
339		* invoke task throws exception when task completes abnormally
340		*/
341		public void testAbnormalInvoke() {
342	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
343	<	public Integer compute() {
342	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
343	>	public Integer realCompute() {
344	>	FailingFibTask f = new FailingFibTask(8);
345		try {
214	–	FailingFibTask f = new FailingFibTask(8);
346		f.invoke();
347		shouldThrow();
217	–	return NoResult;
348		} catch (FJException success) {
349	+	checkCompletedAbnormally(f, success);
350		}
351		return NoResult;
352	<	}
353	<	};
223	<	mainPool.invoke(a);
352	>	}};
353	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
354		}
355
356		/**
357		* quietlyInvoke task returns when task completes abnormally
358		*/
359		public void testAbnormalQuietlyInvoke() {
360	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
361	<	public Integer compute() {
360	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
361	>	public Integer realCompute() {
362		FailingFibTask f = new FailingFibTask(8);
363		f.quietlyInvoke();
364	<	threadAssertTrue(f.isDone());
364	>	assertTrue(f.getException() instanceof FJException);
365	>	checkCompletedAbnormally(f, f.getException());
366		return NoResult;
367	<	}
368	<	};
238	<	mainPool.invoke(a);
367	>	}};
368	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
369		}
370
371		/**
372		* join of a forked task throws exception when task completes abnormally
373		*/
374		public void testAbnormalForkJoin() {
375	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
376	<	public Integer compute() {
375	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
376	>	public Integer realCompute() {
377	>	FailingFibTask f = new FailingFibTask(8);
378	>	assertSame(f, f.fork());
379		try {
248	–	FailingFibTask f = new FailingFibTask(8);
249	–	f.fork();
380		Integer r = f.join();
381		shouldThrow();
252	–	return r;
382		} catch (FJException success) {
383	+	checkCompletedAbnormally(f, success);
384		}
385		return NoResult;
386	<	}
387	<	};
258	<	mainPool.invoke(a);
386	>	}};
387	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
388		}
389
390		/**
391		* get of a forked task throws exception when task completes abnormally
392		*/
393		public void testAbnormalForkGet() {
394	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
395	<	public Integer compute() {
394	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
395	>	public Integer realCompute() throws Exception {
396	>	FailingFibTask f = new FailingFibTask(8);
397	>	assertSame(f, f.fork());
398		try {
268	–	FailingFibTask f = new FailingFibTask(8);
269	–	f.fork();
399		Integer r = f.get();
400		shouldThrow();
272	–	return r;
401		} catch (ExecutionException success) {
402	<	} catch (Exception ex) {
403	<	unexpectedException(ex);
402	>	Throwable cause = success.getCause();
403	>	assertTrue(cause instanceof FJException);
404	>	checkCompletedAbnormally(f, cause);
405		}
406		return NoResult;
407	<	}
408	<	};
280	<	mainPool.invoke(a);
407	>	}};
408	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
409		}
410
411		/**
412		* timed get of a forked task throws exception when task completes abnormally
413		*/
414		public void testAbnormalForkTimedGet() {
415	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
416	<	public Integer compute() {
415	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
416	>	public Integer realCompute() throws Exception {
417	>	FailingFibTask f = new FailingFibTask(8);
418	>	assertSame(f, f.fork());
419		try {
420	<	FailingFibTask f = new FailingFibTask(8);
291	<	f.fork();
292	<	Integer r = f.get(5L, TimeUnit.SECONDS);
420	>	Integer r = f.get(5L, SECONDS);
421		shouldThrow();
294	–	return r;
422		} catch (ExecutionException success) {
423	<	} catch (Exception ex) {
424	<	unexpectedException(ex);
423	>	Throwable cause = success.getCause();
424	>	assertTrue(cause instanceof FJException);
425	>	checkCompletedAbnormally(f, cause);
426		}
427		return NoResult;
428	<	}
429	<	};
302	<	mainPool.invoke(a);
428	>	}};
429	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
430		}
431
432		/**
433		* quietlyJoin of a forked task returns when task completes abnormally
434		*/
435		public void testAbnormalForkQuietlyJoin() {
436	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
437	<	public Integer compute() {
436	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
437	>	public Integer realCompute() {
438		FailingFibTask f = new FailingFibTask(8);
439	<	f.fork();
439	>	assertSame(f, f.fork());
440		f.quietlyJoin();
441	<	threadAssertTrue(f.isDone());
442	<	threadAssertTrue(f.isCompletedAbnormally());
316	<	threadAssertTrue(f.getException() instanceof FJException);
441	>	assertTrue(f.getException() instanceof FJException);
442	>	checkCompletedAbnormally(f, f.getException());
443		return NoResult;
444	<	}
445	<	};
320	<	mainPool.invoke(a);
444	>	}};
445	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
446		}
447
448		/**
449		* invoke task throws exception when task cancelled
450		*/
451		public void testCancelledInvoke() {
452	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
453	<	public Integer compute() {
452	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
453	>	public Integer realCompute() {
454	>	FibTask f = new FibTask(8);
455	>	assertTrue(f.cancel(true));
456		try {
330	–	FibTask f = new FibTask(8);
331	–	f.cancel(true);
457		Integer r = f.invoke();
458		shouldThrow();
334	–	return r;
459		} catch (CancellationException success) {
460	+	checkCancelled(f);
461		}
462		return NoResult;
463	<	}
464	<	};
340	<	mainPool.invoke(a);
463	>	}};
464	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
465		}
466
467		/**
468		* join of a forked task throws exception when task cancelled
469		*/
470		public void testCancelledForkJoin() {
471	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
472	<	public Integer compute() {
471	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
472	>	public Integer realCompute() {
473	>	FibTask f = new FibTask(8);
474	>	assertTrue(f.cancel(true));
475	>	assertSame(f, f.fork());
476		try {
350	–	FibTask f = new FibTask(8);
351	–	f.cancel(true);
352	–	f.fork();
477		Integer r = f.join();
478		shouldThrow();
355	–	return r;
479		} catch (CancellationException success) {
480	+	checkCancelled(f);
481		}
482		return NoResult;
483	<	}
484	<	};
361	<	mainPool.invoke(a);
483	>	}};
484	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
485		}
486
487		/**
488		* get of a forked task throws exception when task cancelled
489		*/
490		public void testCancelledForkGet() {
491	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
492	<	public Integer compute() {
491	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
492	>	public Integer realCompute() throws Exception {
493	>	FibTask f = new FibTask(8);
494	>	assertTrue(f.cancel(true));
495	>	assertSame(f, f.fork());
496		try {
371	–	FibTask f = new FibTask(8);
372	–	f.cancel(true);
373	–	f.fork();
497		Integer r = f.get();
498		shouldThrow();
376	–	return r;
499		} catch (CancellationException success) {
500	<	} catch (Exception ex) {
379	<	unexpectedException(ex);
500	>	checkCancelled(f);
501		}
502		return NoResult;
503	<	}
504	<	};
384	<	mainPool.invoke(a);
503	>	}};
504	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
505		}
506
507		/**
508		* timed get of a forked task throws exception when task cancelled
509		*/
510		public void testCancelledForkTimedGet() {
511	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
512	<	public Integer compute() {
511	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
512	>	public Integer realCompute() throws Exception {
513	>	FibTask f = new FibTask(8);
514	>	assertTrue(f.cancel(true));
515	>	assertSame(f, f.fork());
516		try {
517	<	FibTask f = new FibTask(8);
395	<	f.cancel(true);
396	<	f.fork();
397	<	Integer r = f.get(5L, TimeUnit.SECONDS);
517	>	Integer r = f.get(5L, SECONDS);
518		shouldThrow();
399	–	return r;
519		} catch (CancellationException success) {
520	<	} catch (Exception ex) {
402	<	unexpectedException(ex);
520	>	checkCancelled(f);
521		}
522		return NoResult;
523	<	}
524	<	};
407	<	mainPool.invoke(a);
523	>	}};
524	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
525		}
526
527		/**
528		* quietlyJoin of a forked task returns when task cancelled
529		*/
530		public void testCancelledForkQuietlyJoin() {
531	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
532	<	public Integer compute() {
531	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
532	>	public Integer realCompute() {
533		FibTask f = new FibTask(8);
534	<	f.cancel(true);
535	<	f.fork();
534	>	assertTrue(f.cancel(true));
535	>	assertSame(f, f.fork());
536		f.quietlyJoin();
537	<	threadAssertTrue(f.isDone());
421	<	threadAssertTrue(f.isCompletedAbnormally());
422	<	threadAssertTrue(f.getException() instanceof CancellationException);
537	>	checkCancelled(f);
538		return NoResult;
539	<	}
540	<	};
426	<	mainPool.invoke(a);
539	>	}};
540	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
541		}
542
543		/**
544		* getPool of executing task returns its pool
545		*/
546		public void testGetPool() {
547	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
548	<	public Integer compute() {
549	<	threadAssertTrue(getPool() == mainPool);
547	>	final ForkJoinPool mainPool = mainPool();
548	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
549	>	public Integer realCompute() {
550	>	assertSame(mainPool, getPool());
551		return NoResult;
552	<	}
553	<	};
439	<	mainPool.invoke(a);
552	>	}};
553	>	assertSame(NoResult, testInvokeOnPool(mainPool, a));
554		}
555
556		/**
557		* getPool of non-FJ task returns null
558		*/
559		public void testGetPool2() {
560	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
561	<	public Integer compute() {
562	<	threadAssertTrue(getPool() == null);
560	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
561	>	public Integer realCompute() {
562	>	assertNull(getPool());
563		return NoResult;
564	<	}
565	<	};
452	<	a.invoke();
564	>	}};
565	>	assertSame(NoResult, a.invoke());
566		}
567
568		/**
569		* inForkJoinPool of executing task returns true
570		*/
571		public void testInForkJoinPool() {
572	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
573	<	public Integer compute() {
574	<	threadAssertTrue(inForkJoinPool());
572	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
573	>	public Integer realCompute() {
574	>	assertTrue(inForkJoinPool());
575		return NoResult;
576	<	}
577	<	};
465	<	mainPool.invoke(a);
576	>	}};
577	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
578		}
579
580		/**
581		* inForkJoinPool of non-FJ task returns false
582		*/
583		public void testInForkJoinPool2() {
584	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
585	<	public Integer compute() {
586	<	threadAssertTrue(!inForkJoinPool());
584	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
585	>	public Integer realCompute() {
586	>	assertFalse(inForkJoinPool());
587		return NoResult;
588	<	}
589	<	};
478	<	a.invoke();
588	>	}};
589	>	assertSame(NoResult, a.invoke());
590		}
591
592		/**
593	<	* setRawResult(null) succeeds
593	>	* The value set by setRawResult is returned by getRawResult
594		*/
595		public void testSetRawResult() {
596	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
597	<	public Integer compute() {
596	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
597	>	public Integer realCompute() {
598		setRawResult(NoResult);
599	+	assertSame(NoResult, getRawResult());
600		return NoResult;
601		}
602		};
603	<	assertEquals(a.invoke(), NoResult);
603	>	assertSame(NoResult, a.invoke());
604		}
605
606		/**
607	<	* A reinitialized task may be re-invoked
607	>	* A reinitialized normally completed task may be re-invoked
608		*/
609		public void testReinitialize() {
610	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
611	<	public Integer compute() {
610	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
611	>	public Integer realCompute() {
612		FibTask f = new FibTask(8);
613	<	Integer r = f.invoke();
614	<	threadAssertTrue(r == 21);
615	<	threadAssertTrue(f.isDone());
616	<	threadAssertFalse(f.isCancelled());
617	<	threadAssertFalse(f.isCompletedAbnormally());
618	<	f.reinitialize();
619	<	r = f.invoke();
620	<	threadAssertTrue(r == 21);
613	>	checkNotDone(f);
614	>
615	>	for (int i = 0; i < 3; i++) {
616	>	Integer r = f.invoke();
617	>	assertEquals(21, (int) r);
618	>	checkCompletedNormally(f, r);
619	>	f.reinitialize();
620	>	f.publicSetRawResult(null);
621	>	checkNotDone(f);
622	>	}
623		return NoResult;
624	<	}
625	<	};
626	<	mainPool.invoke(a);
624	>	}};
625	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
626	>	}
627	>
628	>	/**
629	>	* A reinitialized abnormally completed task may be re-invoked
630	>	*/
631	>	public void testReinitializeAbnormal() {
632	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
633	>	public Integer realCompute() {
634	>	FailingFibTask f = new FailingFibTask(8);
635	>	checkNotDone(f);
636	>
637	>	for (int i = 0; i < 3; i++) {
638	>	try {
639	>	f.invoke();
640	>	shouldThrow();
641	>	} catch (FJException success) {
642	>	checkCompletedAbnormally(f, success);
643	>	}
644	>	f.reinitialize();
645	>	checkNotDone(f);
646	>	}
647	>	return NoResult;
648	>	}};
649	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
650		}
651
652		/**
653		* invoke task throws exception after invoking completeExceptionally
654		*/
655		public void testCompleteExceptionally() {
656	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
657	<	public Integer compute() {
656	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
657	>	public Integer realCompute() {
658	>	FibTask f = new FibTask(8);
659	>	f.completeExceptionally(new FJException());
660		try {
522	–	FibTask f = new FibTask(8);
523	–	f.completeExceptionally(new FJException());
661		Integer r = f.invoke();
662		shouldThrow();
526	–	return r;
663		} catch (FJException success) {
664	+	checkCompletedAbnormally(f, success);
665		}
666		return NoResult;
667	<	}
668	<	};
532	<	mainPool.invoke(a);
667	>	}};
668	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
669		}
670
671		/**
672		* invoke task suppresses execution invoking complete
673		*/
674		public void testComplete() {
675	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
676	<	public Integer compute() {
675	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
676	>	public Integer realCompute() {
677		FibTask f = new FibTask(8);
678		f.complete(NoResult);
679		Integer r = f.invoke();
680	<	threadAssertTrue(f.isDone());
681	<	threadAssertTrue(r == NoResult);
680	>	assertSame(NoResult, r);
681	>	checkCompletedNormally(f, NoResult);
682		return r;
683	<	}
684	<	};
549	<	mainPool.invoke(a);
683	>	}};
684	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
685		}
686
687		/**
688		* invokeAll(t1, t2) invokes all task arguments
689		*/
690		public void testInvokeAll2() {
691	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
692	<	public Integer compute() {
691	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
692	>	public Integer realCompute() {
693		FibTask f = new FibTask(8);
694		FibTask g = new FibTask(9);
695		invokeAll(f, g);
696	<	threadAssertTrue(f.isDone());
697	<	threadAssertTrue(f.join() == 21);
563	<	threadAssertTrue(g.isDone());
564	<	threadAssertTrue(g.join() == 34);
696	>	checkCompletedNormally(f, 21);
697	>	checkCompletedNormally(g, 34);
698		return NoResult;
699	<	}
700	<	};
568	<	mainPool.invoke(a);
699	>	}};
700	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
701		}
702
703		/**
704		* invokeAll(tasks) with 1 argument invokes task
705		*/
706		public void testInvokeAll1() {
707	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
708	<	public Integer compute() {
707	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
708	>	public Integer realCompute() {
709		FibTask f = new FibTask(8);
710		invokeAll(f);
711	<	threadAssertTrue(f.isDone());
580	<	threadAssertTrue(f.join() == 21);
711	>	checkCompletedNormally(f, 21);
712		return NoResult;
713	<	}
714	<	};
584	<	mainPool.invoke(a);
713	>	}};
714	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
715		}
716
717		/**
718		* invokeAll(tasks) with > 2 argument invokes tasks
719		*/
720		public void testInvokeAll3() {
721	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
722	<	public Integer compute() {
721	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
722	>	public Integer realCompute() {
723		FibTask f = new FibTask(8);
724		FibTask g = new FibTask(9);
725		FibTask h = new FibTask(7);
726		invokeAll(f, g, h);
727	<	threadAssertTrue(f.isDone());
728	<	threadAssertTrue(f.join() == 21);
729	<	threadAssertTrue(g.isDone());
730	<	threadAssertTrue(g.join() == 34);
731	<	threadAssertTrue(h.isDone());
732	<	threadAssertTrue(h.join() == 13);
727	>	assertTrue(f.isDone());
728	>	assertTrue(g.isDone());
729	>	assertTrue(h.isDone());
730	>	checkCompletedNormally(f, 21);
731	>	checkCompletedNormally(g, 34);
732	>	checkCompletedNormally(h, 13);
733		return NoResult;
734	<	}
735	<	};
606	<	mainPool.invoke(a);
734	>	}};
735	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
736		}
737
738		/**
739		* invokeAll(collection) invokes all tasks in the collection
740		*/
741		public void testInvokeAllCollection() {
742	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
743	<	public Integer compute() {
742	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
743	>	public Integer realCompute() {
744		FibTask f = new FibTask(8);
745		FibTask g = new FibTask(9);
746		FibTask h = new FibTask(7);
#	Line 620 | Line 749 | public class RecursiveTaskTest extends J
749		set.add(g);
750		set.add(h);
751		invokeAll(set);
752	<	threadAssertTrue(f.isDone());
753	<	threadAssertTrue(f.join() == 21);
754	<	threadAssertTrue(g.isDone());
755	<	threadAssertTrue(g.join() == 34);
756	<	threadAssertTrue(h.isDone());
757	<	threadAssertTrue(h.join() == 13);
752	>	assertTrue(f.isDone());
753	>	assertTrue(g.isDone());
754	>	assertTrue(h.isDone());
755	>	checkCompletedNormally(f, 21);
756	>	checkCompletedNormally(g, 34);
757	>	checkCompletedNormally(h, 13);
758		return NoResult;
759	<	}
760	<	};
632	<	mainPool.invoke(a);
759	>	}};
760	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
761		}
762
763	+	/**
764	+	* invokeAll(tasks) with any null task throws NPE
765	+	*/
766	+	public void testInvokeAllNPE() {
767	+	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
768	+	public Integer realCompute() {
769	+	FibTask f = new FibTask(8);
770	+	FibTask g = new FibTask(9);
771	+	FibTask h = null;
772	+	try {
773	+	invokeAll(f, g, h);
774	+	shouldThrow();
775	+	} catch (NullPointerException success) {}
776	+	return NoResult;
777	+	}};
778	+	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
779	+	}
780
781		/**
782		* invokeAll(t1, t2) throw exception if any task does
783		*/
784		public void testAbnormalInvokeAll2() {
785	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
786	<	public Integer compute() {
785	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
786	>	public Integer realCompute() {
787	>	FibTask f = new FibTask(8);
788	>	FailingFibTask g = new FailingFibTask(9);
789		try {
643	–	FibTask f = new FibTask(8);
644	–	FailingFibTask g = new FailingFibTask(9);
790		invokeAll(f, g);
791		shouldThrow();
647	–	return NoResult;
792		} catch (FJException success) {
793	+	checkCompletedAbnormally(g, success);
794		}
795		return NoResult;
796	<	}
797	<	};
653	<	mainPool.invoke(a);
796	>	}};
797	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
798		}
799
800		/**
801		* invokeAll(tasks) with 1 argument throws exception if task does
802		*/
803		public void testAbnormalInvokeAll1() {
804	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
805	<	public Integer compute() {
804	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
805	>	public Integer realCompute() {
806	>	FailingFibTask g = new FailingFibTask(9);
807		try {
663	–	FailingFibTask g = new FailingFibTask(9);
808		invokeAll(g);
809		shouldThrow();
666	–	return NoResult;
810		} catch (FJException success) {
811	+	checkCompletedAbnormally(g, success);
812		}
813		return NoResult;
814	<	}
815	<	};
672	<	mainPool.invoke(a);
814	>	}};
815	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
816		}
817
818		/**
819		* invokeAll(tasks) with > 2 argument throws exception if any task does
820		*/
821		public void testAbnormalInvokeAll3() {
822	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
823	<	public Integer compute() {
822	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
823	>	public Integer realCompute() {
824	>	FibTask f = new FibTask(8);
825	>	FailingFibTask g = new FailingFibTask(9);
826	>	FibTask h = new FibTask(7);
827		try {
682	–	FibTask f = new FibTask(8);
683	–	FailingFibTask g = new FailingFibTask(9);
684	–	FibTask h = new FibTask(7);
828		invokeAll(f, g, h);
829		shouldThrow();
687	–	return NoResult;
830		} catch (FJException success) {
831	+	checkCompletedAbnormally(g, success);
832		}
833		return NoResult;
834	<	}
835	<	};
693	<	mainPool.invoke(a);
834	>	}};
835	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
836		}
837
838		/**
839		* invokeAll(collection) throws exception if any task does
840		*/
841		public void testAbnormalInvokeAllCollection() {
842	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
843	<	public Integer compute() {
842	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
843	>	public Integer realCompute() {
844	>	FailingFibTask f = new FailingFibTask(8);
845	>	FibTask g = new FibTask(9);
846	>	FibTask h = new FibTask(7);
847	>	HashSet set = new HashSet();
848	>	set.add(f);
849	>	set.add(g);
850	>	set.add(h);
851		try {
703	–	FailingFibTask f = new FailingFibTask(8);
704	–	FibTask g = new FibTask(9);
705	–	FibTask h = new FibTask(7);
706	–	HashSet set = new HashSet();
707	–	set.add(f);
708	–	set.add(g);
709	–	set.add(h);
852		invokeAll(set);
853		shouldThrow();
712	–	return NoResult;
854		} catch (FJException success) {
855	+	checkCompletedAbnormally(f, success);
856		}
857		return NoResult;
858	<	}
859	<	};
718	<	mainPool.invoke(a);
858	>	}};
859	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
860		}
861
862		/**
#	Line 723 | Line 864 | public class RecursiveTaskTest extends J
864		* and suppresses execution
865		*/
866		public void testTryUnfork() {
867	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
868	<	public Integer compute() {
867	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
868	>	public Integer realCompute() {
869		FibTask g = new FibTask(9);
870	<	g.fork();
870	>	assertSame(g, g.fork());
871		FibTask f = new FibTask(8);
872	<	f.fork();
873	<	threadAssertTrue(f.tryUnfork());
872	>	assertSame(f, f.fork());
873	>	assertTrue(f.tryUnfork());
874		helpQuiesce();
875	<	threadAssertFalse(f.isDone());
876	<	threadAssertTrue(g.isDone());
875	>	checkNotDone(f);
876	>	checkCompletedNormally(g, 34);
877		return NoResult;
878	<	}
879	<	};
739	<	singletonPool.invoke(a);
878	>	}};
879	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
880		}
881
882		/**
#	Line 744 | Line 884 | public class RecursiveTaskTest extends J
884		* there are more tasks than threads
885		*/
886		public void testGetSurplusQueuedTaskCount() {
887	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
888	<	public Integer compute() {
887	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
888	>	public Integer realCompute() {
889		FibTask h = new FibTask(7);
890	<	h.fork();
890	>	assertSame(h, h.fork());
891		FibTask g = new FibTask(9);
892	<	g.fork();
892	>	assertSame(g, g.fork());
893		FibTask f = new FibTask(8);
894	<	f.fork();
895	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
894	>	assertSame(f, f.fork());
895	>	assertTrue(getSurplusQueuedTaskCount() > 0);
896		helpQuiesce();
897	+	assertEquals(0, getSurplusQueuedTaskCount());
898	+	checkCompletedNormally(f, 21);
899	+	checkCompletedNormally(g, 34);
900	+	checkCompletedNormally(h, 13);
901		return NoResult;
902	<	}
903	<	};
760	<	singletonPool.invoke(a);
902	>	}};
903	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
904		}
905
906		/**
907		* peekNextLocalTask returns most recent unexecuted task.
908		*/
909		public void testPeekNextLocalTask() {
910	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
911	<	public Integer compute() {
910	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
911	>	public Integer realCompute() {
912		FibTask g = new FibTask(9);
913	<	g.fork();
913	>	assertSame(g, g.fork());
914		FibTask f = new FibTask(8);
915	<	f.fork();
916	<	threadAssertTrue(peekNextLocalTask() == f);
917	<	f.join();
775	<	threadAssertTrue(f.isDone());
915	>	assertSame(f, f.fork());
916	>	assertSame(f, peekNextLocalTask());
917	>	checkCompletesNormally(f, 21);
918		helpQuiesce();
919	+	checkCompletedNormally(g, 34);
920		return NoResult;
921	<	}
922	<	};
780	<	singletonPool.invoke(a);
921	>	}};
922	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
923		}
924
925		/**
#	Line 785 | Line 927 | public class RecursiveTaskTest extends J
927		* without executing it
928		*/
929		public void testPollNextLocalTask() {
930	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
931	<	public Integer compute() {
930	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
931	>	public Integer realCompute() {
932		FibTask g = new FibTask(9);
933	<	g.fork();
933	>	assertSame(g, g.fork());
934		FibTask f = new FibTask(8);
935	<	f.fork();
936	<	threadAssertTrue(pollNextLocalTask() == f);
935	>	assertSame(f, f.fork());
936	>	assertSame(f, pollNextLocalTask());
937		helpQuiesce();
938	<	threadAssertFalse(f.isDone());
938	>	checkNotDone(f);
939	>	checkCompletedNormally(g, 34);
940		return NoResult;
941	<	}
942	<	};
800	<	singletonPool.invoke(a);
941	>	}};
942	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
943		}
944
945		/**
946	<	* pollTask returns an unexecuted task
805	<	* without executing it
946	>	* pollTask returns an unexecuted task without executing it
947		*/
948		public void testPollTask() {
949	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
950	<	public Integer compute() {
949	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
950	>	public Integer realCompute() {
951		FibTask g = new FibTask(9);
952	<	g.fork();
952	>	assertSame(g, g.fork());
953		FibTask f = new FibTask(8);
954	<	f.fork();
955	<	threadAssertTrue(pollTask() == f);
954	>	assertSame(f, f.fork());
955	>	assertSame(f, pollTask());
956		helpQuiesce();
957	<	threadAssertFalse(f.isDone());
958	<	threadAssertTrue(g.isDone());
957	>	checkNotDone(f);
958	>	checkCompletedNormally(g, 34);
959		return NoResult;
960	<	}
961	<	};
821	<	singletonPool.invoke(a);
960	>	}};
961	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
962		}
963
964		/**
965		* peekNextLocalTask returns least recent unexecuted task in async mode
966		*/
967		public void testPeekNextLocalTaskAsync() {
968	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
969	<	public Integer compute() {
968	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
969	>	public Integer realCompute() {
970		FibTask g = new FibTask(9);
971	<	g.fork();
971	>	assertSame(g, g.fork());
972		FibTask f = new FibTask(8);
973	<	f.fork();
974	<	threadAssertTrue(peekNextLocalTask() == g);
975	<	f.join();
973	>	assertSame(f, f.fork());
974	>	assertSame(g, peekNextLocalTask());
975	>	assertEquals(21, (int) f.join());
976		helpQuiesce();
977	<	threadAssertTrue(f.isDone());
977	>	checkCompletedNormally(f, 21);
978	>	checkCompletedNormally(g, 34);
979		return NoResult;
980	<	}
981	<	};
841	<	asyncSingletonPool.invoke(a);
980	>	}};
981	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
982		}
983
984		/**
985	<	* pollNextLocalTask returns least recent unexecuted task
986	<	* without executing it, in async mode
985	>	* pollNextLocalTask returns least recent unexecuted task without
986	>	* executing it, in async mode
987		*/
988		public void testPollNextLocalTaskAsync() {
989	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
990	<	public Integer compute() {
989	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
990	>	public Integer realCompute() {
991		FibTask g = new FibTask(9);
992	<	g.fork();
992	>	assertSame(g, g.fork());
993		FibTask f = new FibTask(8);
994	<	f.fork();
995	<	threadAssertTrue(pollNextLocalTask() == g);
994	>	assertSame(f, f.fork());
995	>	assertSame(g, pollNextLocalTask());
996		helpQuiesce();
997	<	threadAssertTrue(f.isDone());
998	<	threadAssertFalse(g.isDone());
997	>	checkCompletedNormally(f, 21);
998	>	checkNotDone(g);
999		return NoResult;
1000	<	}
1001	<	};
862	<	asyncSingletonPool.invoke(a);
1000	>	}};
1001	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
1002		}
1003
1004		/**
1005	<	* pollTask returns an unexecuted task
1006	<	* without executing it, in async mode
1005	>	* pollTask returns an unexecuted task without executing it, in
1006	>	* async mode
1007		*/
1008		public void testPollTaskAsync() {
1009	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
1010	<	public Integer compute() {
1009	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
1010	>	public Integer realCompute() {
1011		FibTask g = new FibTask(9);
1012	<	g.fork();
1012	>	assertSame(g, g.fork());
1013		FibTask f = new FibTask(8);
1014	<	f.fork();
1015	<	threadAssertTrue(pollTask() == g);
1014	>	assertSame(f, f.fork());
1015	>	assertSame(g, pollTask());
1016		helpQuiesce();
1017	<	threadAssertTrue(f.isDone());
1018	<	threadAssertFalse(g.isDone());
1017	>	checkCompletedNormally(f, 21);
1018	>	checkNotDone(g);
1019		return NoResult;
1020	<	}
1021	<	};
883	<	asyncSingletonPool.invoke(a);
1020	>	}};
1021	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
1022		}
1023
1024		}

Diff Legend

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