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.8 by jsr166, Sat Nov 21 02:07:27 2009 UTC vs.
Revision 1.20 by jsr166, Sun Nov 21 08:25:10 2010 UTC

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

Diff Legend

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