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.18 by jsr166, Tue Sep 14 18:38:28 2010 UTC vs.
Revision 1.24 by jsr166, Mon Nov 22 07:45:50 2010 UTC

#	Line 8 | Line 8 | 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 {
#	Line 37 | Line 40 | public class RecursiveTaskTest extends J
40
41		private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
42		try {
43	<	return pool.invoke(a);
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	+	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, a.getException());
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, expected);
165	+	}
166	+
167	+	try {
168	+	a.get();
169	+	shouldThrow();
170	+	} catch (ExecutionException success) {
171	+	assertSame(t, success.getCause());
172	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
173	+
174	+	try {
175	+	a.get(5L, SECONDS);
176	+	shouldThrow();
177	+	} catch (ExecutionException success) {
178	+	assertSame(t, success.getCause());
179	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
180	+	}
181	+
182		static final class FJException extends RuntimeException {
183		FJException() { super(); }
184		}
#	Line 51 | Line 187 | public class RecursiveTaskTest extends J
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 62 | 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 86 | Line 226 | public class RecursiveTaskTest extends J
226		* returns value;
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());
95	<	threadAssertFalse(f.isCancelled());
96	<	threadAssertFalse(f.isCompletedAbnormally());
97	<	threadAssertTrue(f.getRawResult() == 21);
233	>	assertEquals(21, (int) r);
234	>	checkCompletedNormally(f, r);
235		return r;
236	<	}
100	<	};
236	>	}};
237		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
238		}
239
#	Line 107 | 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());
118	<	threadAssertFalse(f.isCompletedAbnormally());
119	<	return r;
120	<	}
121	<	};
122	<	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
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	<	threadAssertSame(f, 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	<	}
138	<	};
268	>	}};
269		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
270		}
271
#	Line 143 | Line 273 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, f.fork());
281	<	Integer r = f.get();
282	<	threadAssertTrue(r == 21);
283	<	threadAssertTrue(f.isDone());
284	<	return r;
155	<	} catch (Exception ex) {
156	<	unexpectedException(ex);
157	<	}
158	<	return NoResult;
159	<	}
160	<	};
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
#	Line 165 | Line 289 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, f.fork());
297	<	Integer r = f.get(5L, TimeUnit.SECONDS);
298	<	threadAssertTrue(r == 21);
299	<	threadAssertTrue(f.isDone());
300	<	return r;
177	<	} catch (Exception ex) {
178	<	unexpectedException(ex);
179	<	}
180	<	return NoResult;
181	<	}
182	<	};
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
#	Line 187 | Line 305 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, 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	<	}
200	<	};
317	>	}};
318		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
319		}
320
#	Line 207 | Line 324 | public class RecursiveTaskTest extends J
324		* getQueuedTaskCount returns 0 when quiescent
325		*/
326		public void testForkHelpQuiesce() {
327	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
328	<	public Integer compute() {
327	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
328	>	public Integer realCompute() {
329		FibTask f = new FibTask(8);
330	<	threadAssertSame(f, f.fork());
330	>	assertSame(f, f.fork());
331		f.helpQuiesce();
332	<	Integer r = f.getRawResult();
333	<	threadAssertTrue(r == 21);
334	<	threadAssertTrue(f.isDone());
335	<	threadAssertTrue(getQueuedTaskCount() == 0);
336	<	return r;
220	<	}
221	<	};
222	<	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
332	>	assertEquals(0, getQueuedTaskCount());
333	>	checkCompletedNormally(f, 21);
334	>	return NoResult;
335	>	}};
336	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
337		}
338
339
#	Line 227 | Line 341 | public class RecursiveTaskTest extends J
341		* invoke task throws exception when task completes abnormally
342		*/
343		public void testAbnormalInvoke() {
344	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
345	<	public Integer compute() {
344	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
345	>	public Integer realCompute() {
346	>	FailingFibTask f = new FailingFibTask(8);
347		try {
233	–	FailingFibTask f = new FailingFibTask(8);
348		f.invoke();
349		shouldThrow();
236	–	return NoResult;
350		} catch (FJException success) {
351	+	checkCompletedAbnormally(f, success);
352		}
353		return NoResult;
354	<	}
241	<	};
354	>	}};
355		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
356		}
357
#	Line 246 | Line 359 | public class RecursiveTaskTest extends J
359		* quietlyInvoke task returns when task completes abnormally
360		*/
361		public void testAbnormalQuietlyInvoke() {
362	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
363	<	public Integer compute() {
362	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
363	>	public Integer realCompute() {
364		FailingFibTask f = new FailingFibTask(8);
365		f.quietlyInvoke();
366	<	threadAssertTrue(f.isDone());
366	>	assertTrue(f.getException() instanceof FJException);
367	>	checkCompletedAbnormally(f, f.getException());
368		return NoResult;
369	<	}
256	<	};
369	>	}};
370		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
371		}
372
#	Line 261 | Line 374 | public class RecursiveTaskTest extends J
374		* join of a forked task throws exception when task completes abnormally
375		*/
376		public void testAbnormalForkJoin() {
377	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
378	<	public Integer compute() {
377	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
378	>	public Integer realCompute() {
379	>	FailingFibTask f = new FailingFibTask(8);
380	>	assertSame(f, f.fork());
381		try {
267	–	FailingFibTask f = new FailingFibTask(8);
268	–	threadAssertSame(f, f.fork());
382		Integer r = f.join();
383		shouldThrow();
271	–	return r;
384		} catch (FJException success) {
385	+	checkCompletedAbnormally(f, success);
386		}
387		return NoResult;
388	<	}
276	<	};
388	>	}};
389		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
390		}
391
#	Line 281 | Line 393 | public class RecursiveTaskTest extends J
393		* get of a forked task throws exception when task completes abnormally
394		*/
395		public void testAbnormalForkGet() {
396	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
397	<	public Integer compute() {
396	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
397	>	public Integer realCompute() throws Exception {
398	>	FailingFibTask f = new FailingFibTask(8);
399	>	assertSame(f, f.fork());
400		try {
287	–	FailingFibTask f = new FailingFibTask(8);
288	–	threadAssertSame(f, f.fork());
401		Integer r = f.get();
402		shouldThrow();
291	–	return r;
403		} catch (ExecutionException success) {
404	<	} catch (Exception ex) {
405	<	unexpectedException(ex);
404	>	Throwable cause = success.getCause();
405	>	assertTrue(cause instanceof FJException);
406	>	checkCompletedAbnormally(f, cause);
407		}
408		return NoResult;
409	<	}
298	<	};
409	>	}};
410		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
411		}
412
#	Line 303 | Line 414 | public class RecursiveTaskTest extends J
414		* timed get of a forked task throws exception when task completes abnormally
415		*/
416		public void testAbnormalForkTimedGet() {
417	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
418	<	public Integer compute() {
417	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
418	>	public Integer realCompute() throws Exception {
419	>	FailingFibTask f = new FailingFibTask(8);
420	>	assertSame(f, f.fork());
421		try {
422	<	FailingFibTask f = new FailingFibTask(8);
310	<	threadAssertSame(f, f.fork());
311	<	Integer r = f.get(5L, TimeUnit.SECONDS);
422	>	Integer r = f.get(5L, SECONDS);
423		shouldThrow();
313	–	return r;
424		} catch (ExecutionException success) {
425	<	} catch (Exception ex) {
426	<	unexpectedException(ex);
425	>	Throwable cause = success.getCause();
426	>	assertTrue(cause instanceof FJException);
427	>	checkCompletedAbnormally(f, cause);
428		}
429		return NoResult;
430	<	}
320	<	};
430	>	}};
431		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
432		}
433
#	Line 325 | Line 435 | public class RecursiveTaskTest extends J
435		* quietlyJoin of a forked task returns when task completes abnormally
436		*/
437		public void testAbnormalForkQuietlyJoin() {
438	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
439	<	public Integer compute() {
438	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
439	>	public Integer realCompute() {
440		FailingFibTask f = new FailingFibTask(8);
441	<	threadAssertSame(f, f.fork());
441	>	assertSame(f, f.fork());
442		f.quietlyJoin();
443	<	threadAssertTrue(f.isDone());
444	<	threadAssertTrue(f.isCompletedAbnormally());
335	<	threadAssertTrue(f.getException() instanceof FJException);
443	>	assertTrue(f.getException() instanceof FJException);
444	>	checkCompletedAbnormally(f, f.getException());
445		return NoResult;
446	<	}
338	<	};
446	>	}};
447		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
448		}
449
#	Line 343 | Line 451 | public class RecursiveTaskTest extends J
451		* invoke task throws exception when task cancelled
452		*/
453		public void testCancelledInvoke() {
454	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
455	<	public Integer compute() {
454	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
455	>	public Integer realCompute() {
456	>	FibTask f = new FibTask(8);
457	>	assertTrue(f.cancel(true));
458		try {
349	–	FibTask f = new FibTask(8);
350	–	threadAssertTrue(f.cancel(true));
459		Integer r = f.invoke();
460		shouldThrow();
353	–	return r;
461		} catch (CancellationException success) {
462	+	checkCancelled(f);
463		}
464		return NoResult;
465	<	}
358	<	};
465	>	}};
466		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
467		}
468
#	Line 363 | Line 470 | public class RecursiveTaskTest extends J
470		* join of a forked task throws exception when task cancelled
471		*/
472		public void testCancelledForkJoin() {
473	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
474	<	public Integer compute() {
473	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
474	>	public Integer realCompute() {
475	>	FibTask f = new FibTask(8);
476	>	assertTrue(f.cancel(true));
477	>	assertSame(f, f.fork());
478		try {
369	–	FibTask f = new FibTask(8);
370	–	threadAssertTrue(f.cancel(true));
371	–	threadAssertSame(f, f.fork());
479		Integer r = f.join();
480		shouldThrow();
374	–	return r;
481		} catch (CancellationException success) {
482	+	checkCancelled(f);
483		}
484		return NoResult;
485	<	}
379	<	};
485	>	}};
486		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
487		}
488
#	Line 384 | Line 490 | public class RecursiveTaskTest extends J
490		* get of a forked task throws exception when task cancelled
491		*/
492		public void testCancelledForkGet() {
493	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
494	<	public Integer compute() {
493	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
494	>	public Integer realCompute() throws Exception {
495	>	FibTask f = new FibTask(8);
496	>	assertTrue(f.cancel(true));
497	>	assertSame(f, f.fork());
498		try {
390	–	FibTask f = new FibTask(8);
391	–	threadAssertTrue(f.cancel(true));
392	–	threadAssertSame(f, f.fork());
499		Integer r = f.get();
500		shouldThrow();
395	–	return r;
501		} catch (CancellationException success) {
502	<	} catch (Exception ex) {
398	<	unexpectedException(ex);
502	>	checkCancelled(f);
503		}
504		return NoResult;
505	<	}
402	<	};
505	>	}};
506		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
507		}
508
#	Line 407 | Line 510 | public class RecursiveTaskTest extends J
510		* timed get of a forked task throws exception when task cancelled
511		*/
512		public void testCancelledForkTimedGet() {
513	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
514	<	public Integer compute() {
513	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
514	>	public Integer realCompute() throws Exception {
515	>	FibTask f = new FibTask(8);
516	>	assertTrue(f.cancel(true));
517	>	assertSame(f, f.fork());
518		try {
519	<	FibTask f = new FibTask(8);
414	<	threadAssertTrue(f.cancel(true));
415	<	threadAssertSame(f, f.fork());
416	<	Integer r = f.get(5L, TimeUnit.SECONDS);
519	>	Integer r = f.get(5L, SECONDS);
520		shouldThrow();
418	–	return r;
521		} catch (CancellationException success) {
522	<	} catch (Exception ex) {
421	<	unexpectedException(ex);
522	>	checkCancelled(f);
523		}
524		return NoResult;
525	<	}
425	<	};
525	>	}};
526		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
527		}
528
#	Line 430 | Line 530 | public class RecursiveTaskTest extends J
530		* quietlyJoin of a forked task returns when task cancelled
531		*/
532		public void testCancelledForkQuietlyJoin() {
533	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
534	<	public Integer compute() {
533	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
534	>	public Integer realCompute() {
535		FibTask f = new FibTask(8);
536	<	threadAssertTrue(f.cancel(true));
537	<	threadAssertSame(f, f.fork());
536	>	assertTrue(f.cancel(true));
537	>	assertSame(f, f.fork());
538		f.quietlyJoin();
539	<	threadAssertTrue(f.isDone());
440	<	threadAssertTrue(f.isCompletedAbnormally());
441	<	threadAssertTrue(f.getException() instanceof CancellationException);
539	>	checkCancelled(f);
540		return NoResult;
541	<	}
444	<	};
541	>	}};
542		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
543		}
544
#	Line 450 | Line 547 | public class RecursiveTaskTest extends J
547		*/
548		public void testGetPool() {
549		final ForkJoinPool mainPool = mainPool();
550	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
551	<	public Integer compute() {
552	<	threadAssertTrue(getPool() == mainPool);
550	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
551	>	public Integer realCompute() {
552	>	assertSame(mainPool, getPool());
553		return NoResult;
554	<	}
458	<	};
554	>	}};
555		assertSame(NoResult, testInvokeOnPool(mainPool, a));
556		}
557
#	Line 463 | Line 559 | public class RecursiveTaskTest extends J
559		* getPool of non-FJ task returns null
560		*/
561		public void testGetPool2() {
562	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
563	<	public Integer compute() {
564	<	threadAssertTrue(getPool() == null);
562	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
563	>	public Integer realCompute() {
564	>	assertNull(getPool());
565		return NoResult;
566	<	}
471	<	};
566	>	}};
567		assertSame(NoResult, a.invoke());
568		}
569
#	Line 476 | Line 571 | public class RecursiveTaskTest extends J
571		* inForkJoinPool of executing task returns true
572		*/
573		public void testInForkJoinPool() {
574	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
575	<	public Integer compute() {
576	<	threadAssertTrue(inForkJoinPool());
574	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
575	>	public Integer realCompute() {
576	>	assertTrue(inForkJoinPool());
577		return NoResult;
578	<	}
484	<	};
578	>	}};
579		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
580		}
581
#	Line 489 | Line 583 | public class RecursiveTaskTest extends J
583		* inForkJoinPool of non-FJ task returns false
584		*/
585		public void testInForkJoinPool2() {
586	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
587	<	public Integer compute() {
588	<	threadAssertTrue(!inForkJoinPool());
586	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
587	>	public Integer realCompute() {
588	>	assertFalse(inForkJoinPool());
589		return NoResult;
590	<	}
497	<	};
590	>	}};
591		assertSame(NoResult, a.invoke());
592		}
593
#	Line 502 | Line 595 | public class RecursiveTaskTest extends J
595		* The value set by setRawResult is returned by getRawResult
596		*/
597		public void testSetRawResult() {
598	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
599	<	public Integer compute() {
598	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
599	>	public Integer realCompute() {
600		setRawResult(NoResult);
601	<	threadAssertSame(NoResult, getRawResult());
601	>	assertSame(NoResult, getRawResult());
602		return NoResult;
603		}
604		};
605	<	a.invoke();
605	>	assertSame(NoResult, a.invoke());
606		}
607
608		/**
609	<	* A reinitialized task may be re-invoked
609	>	* A reinitialized normally completed task may be re-invoked
610		*/
611		public void testReinitialize() {
612	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
613	<	public Integer compute() {
612	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
613	>	public Integer realCompute() {
614		FibTask f = new FibTask(8);
615	<	Integer r = f.invoke();
616	<	threadAssertTrue(r == 21);
617	<	threadAssertTrue(f.isDone());
618	<	threadAssertFalse(f.isCancelled());
619	<	threadAssertFalse(f.isCompletedAbnormally());
620	<	f.reinitialize();
621	<	r = f.invoke();
622	<	threadAssertTrue(r == 21);
615	>	checkNotDone(f);
616	>
617	>	for (int i = 0; i < 3; i++) {
618	>	Integer r = f.invoke();
619	>	assertEquals(21, (int) r);
620	>	checkCompletedNormally(f, r);
621	>	f.reinitialize();
622	>	f.publicSetRawResult(null);
623	>	checkNotDone(f);
624	>	}
625		return NoResult;
626	<	}
627	<	};
626	>	}};
627	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
628	>	}
629	>
630	>	/**
631	>	* A reinitialized abnormally completed task may be re-invoked
632	>	*/
633	>	public void testReinitializeAbnormal() {
634	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
635	>	public Integer realCompute() {
636	>	FailingFibTask f = new FailingFibTask(8);
637	>	checkNotDone(f);
638	>
639	>	for (int i = 0; i < 3; i++) {
640	>	try {
641	>	f.invoke();
642	>	shouldThrow();
643	>	} catch (FJException success) {
644	>	checkCompletedAbnormally(f, success);
645	>	}
646	>	f.reinitialize();
647	>	checkNotDone(f);
648	>	}
649	>	return NoResult;
650	>	}};
651		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
652		}
653
#	Line 537 | Line 655 | public class RecursiveTaskTest extends J
655		* invoke task throws exception after invoking completeExceptionally
656		*/
657		public void testCompleteExceptionally() {
658	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
659	<	public Integer compute() {
658	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
659	>	public Integer realCompute() {
660	>	FibTask f = new FibTask(8);
661	>	f.completeExceptionally(new FJException());
662		try {
543	–	FibTask f = new FibTask(8);
544	–	f.completeExceptionally(new FJException());
663		Integer r = f.invoke();
664		shouldThrow();
547	–	return r;
665		} catch (FJException success) {
666	+	checkCompletedAbnormally(f, success);
667		}
668		return NoResult;
669	<	}
552	<	};
669	>	}};
670		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
671		}
672
#	Line 557 | Line 674 | public class RecursiveTaskTest extends J
674		* invoke task suppresses execution invoking complete
675		*/
676		public void testComplete() {
677	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
678	<	public Integer compute() {
677	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
678	>	public Integer realCompute() {
679		FibTask f = new FibTask(8);
680		f.complete(NoResult);
681		Integer r = f.invoke();
682	<	threadAssertTrue(f.isDone());
683	<	threadAssertTrue(r == NoResult);
682	>	assertSame(NoResult, r);
683	>	checkCompletedNormally(f, NoResult);
684		return r;
685	<	}
569	<	};
685	>	}};
686		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
687		}
688
#	Line 574 | Line 690 | public class RecursiveTaskTest extends J
690		* invokeAll(t1, t2) invokes all task arguments
691		*/
692		public void testInvokeAll2() {
693	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
694	<	public Integer compute() {
693	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
694	>	public Integer realCompute() {
695		FibTask f = new FibTask(8);
696		FibTask g = new FibTask(9);
697		invokeAll(f, g);
698	<	threadAssertTrue(f.isDone());
699	<	threadAssertTrue(f.join() == 21);
584	<	threadAssertTrue(g.isDone());
585	<	threadAssertTrue(g.join() == 34);
698	>	checkCompletedNormally(f, 21);
699	>	checkCompletedNormally(g, 34);
700		return NoResult;
701	<	}
588	<	};
701	>	}};
702		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
703		}
704
#	Line 593 | Line 706 | public class RecursiveTaskTest extends J
706		* invokeAll(tasks) with 1 argument invokes task
707		*/
708		public void testInvokeAll1() {
709	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
710	<	public Integer compute() {
709	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
710	>	public Integer realCompute() {
711		FibTask f = new FibTask(8);
712		invokeAll(f);
713	<	threadAssertTrue(f.isDone());
601	<	threadAssertTrue(f.join() == 21);
713	>	checkCompletedNormally(f, 21);
714		return NoResult;
715	<	}
604	<	};
715	>	}};
716		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
717		}
718
#	Line 609 | Line 720 | public class RecursiveTaskTest extends J
720		* invokeAll(tasks) with > 2 argument invokes tasks
721		*/
722		public void testInvokeAll3() {
723	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
724	<	public Integer compute() {
723	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
724	>	public Integer realCompute() {
725		FibTask f = new FibTask(8);
726		FibTask g = new FibTask(9);
727		FibTask h = new FibTask(7);
728		invokeAll(f, g, h);
729	<	threadAssertTrue(f.isDone());
730	<	threadAssertTrue(f.join() == 21);
731	<	threadAssertTrue(g.isDone());
732	<	threadAssertTrue(g.join() == 34);
733	<	threadAssertTrue(h.isDone());
734	<	threadAssertTrue(h.join() == 13);
729	>	assertTrue(f.isDone());
730	>	assertTrue(g.isDone());
731	>	assertTrue(h.isDone());
732	>	checkCompletedNormally(f, 21);
733	>	checkCompletedNormally(g, 34);
734	>	checkCompletedNormally(h, 13);
735		return NoResult;
736	<	}
626	<	};
736	>	}};
737		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
738		}
739
#	Line 631 | Line 741 | public class RecursiveTaskTest extends J
741		* invokeAll(collection) invokes all tasks in the collection
742		*/
743		public void testInvokeAllCollection() {
744	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
745	<	public Integer compute() {
744	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
745	>	public Integer realCompute() {
746		FibTask f = new FibTask(8);
747		FibTask g = new FibTask(9);
748		FibTask h = new FibTask(7);
#	Line 641 | Line 751 | public class RecursiveTaskTest extends J
751		set.add(g);
752		set.add(h);
753		invokeAll(set);
754	<	threadAssertTrue(f.isDone());
755	<	threadAssertTrue(f.join() == 21);
756	<	threadAssertTrue(g.isDone());
757	<	threadAssertTrue(g.join() == 34);
758	<	threadAssertTrue(h.isDone());
759	<	threadAssertTrue(h.join() == 13);
754	>	assertTrue(f.isDone());
755	>	assertTrue(g.isDone());
756	>	assertTrue(h.isDone());
757	>	checkCompletedNormally(f, 21);
758	>	checkCompletedNormally(g, 34);
759	>	checkCompletedNormally(h, 13);
760		return NoResult;
761	<	}
652	<	};
761	>	}};
762		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
763		}
764
765
766		/**
767	+	* invokeAll(tasks) with any null task throws NPE
768	+	*/
769	+	public void testInvokeAllNPE() {
770	+	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
771	+	public Integer realCompute() {
772	+	FibTask f = new FibTask(8);
773	+	FibTask g = new FibTask(9);
774	+	FibTask h = null;
775	+	try {
776	+	invokeAll(f, g, h);
777	+	shouldThrow();
778	+	} catch (NullPointerException success) {}
779	+	return NoResult;
780	+	}};
781	+	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
782	+	}
783	+
784	+	/**
785		* invokeAll(t1, t2) throw exception if any task does
786		*/
787		public void testAbnormalInvokeAll2() {
788	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
789	<	public Integer compute() {
788	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
789	>	public Integer realCompute() {
790	>	FibTask f = new FibTask(8);
791	>	FailingFibTask g = new FailingFibTask(9);
792		try {
664	–	FibTask f = new FibTask(8);
665	–	FailingFibTask g = new FailingFibTask(9);
793		invokeAll(f, g);
794		shouldThrow();
668	–	return NoResult;
795		} catch (FJException success) {
796	+	checkCompletedAbnormally(g, success);
797		}
798		return NoResult;
799	<	}
673	<	};
799	>	}};
800		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
801		}
802
#	Line 678 | Line 804 | public class RecursiveTaskTest extends J
804		* invokeAll(tasks) with 1 argument throws exception if task does
805		*/
806		public void testAbnormalInvokeAll1() {
807	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
808	<	public Integer compute() {
807	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
808	>	public Integer realCompute() {
809	>	FailingFibTask g = new FailingFibTask(9);
810		try {
684	–	FailingFibTask g = new FailingFibTask(9);
811		invokeAll(g);
812		shouldThrow();
687	–	return NoResult;
813		} catch (FJException success) {
814	+	checkCompletedAbnormally(g, success);
815		}
816		return NoResult;
817	<	}
692	<	};
817	>	}};
818		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
819		}
820
#	Line 697 | Line 822 | public class RecursiveTaskTest extends J
822		* invokeAll(tasks) with > 2 argument throws exception if any task does
823		*/
824		public void testAbnormalInvokeAll3() {
825	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
826	<	public Integer compute() {
825	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
826	>	public Integer realCompute() {
827	>	FibTask f = new FibTask(8);
828	>	FailingFibTask g = new FailingFibTask(9);
829	>	FibTask h = new FibTask(7);
830		try {
703	–	FibTask f = new FibTask(8);
704	–	FailingFibTask g = new FailingFibTask(9);
705	–	FibTask h = new FibTask(7);
831		invokeAll(f, g, h);
832		shouldThrow();
708	–	return NoResult;
833		} catch (FJException success) {
834	+	checkCompletedAbnormally(g, success);
835		}
836		return NoResult;
837	<	}
713	<	};
837	>	}};
838		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
839		}
840
#	Line 718 | Line 842 | public class RecursiveTaskTest extends J
842		* invokeAll(collection) throws exception if any task does
843		*/
844		public void testAbnormalInvokeAllCollection() {
845	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
846	<	public Integer compute() {
845	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
846	>	public Integer realCompute() {
847	>	FailingFibTask f = new FailingFibTask(8);
848	>	FibTask g = new FibTask(9);
849	>	FibTask h = new FibTask(7);
850	>	HashSet set = new HashSet();
851	>	set.add(f);
852	>	set.add(g);
853	>	set.add(h);
854		try {
724	–	FailingFibTask f = new FailingFibTask(8);
725	–	FibTask g = new FibTask(9);
726	–	FibTask h = new FibTask(7);
727	–	HashSet set = new HashSet();
728	–	set.add(f);
729	–	set.add(g);
730	–	set.add(h);
855		invokeAll(set);
856		shouldThrow();
733	–	return NoResult;
857		} catch (FJException success) {
858	+	checkCompletedAbnormally(f, success);
859		}
860		return NoResult;
861	<	}
738	<	};
861	>	}};
862		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
863		}
864
#	Line 744 | Line 867 | public class RecursiveTaskTest extends J
867		* and suppresses execution
868		*/
869		public void testTryUnfork() {
870	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
871	<	public Integer compute() {
870	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
871	>	public Integer realCompute() {
872		FibTask g = new FibTask(9);
873	<	threadAssertSame(g, g.fork());
873	>	assertSame(g, g.fork());
874		FibTask f = new FibTask(8);
875	<	threadAssertSame(f, f.fork());
876	<	threadAssertTrue(f.tryUnfork());
875	>	assertSame(f, f.fork());
876	>	assertTrue(f.tryUnfork());
877		helpQuiesce();
878	<	threadAssertFalse(f.isDone());
879	<	threadAssertTrue(g.isDone());
878	>	checkNotDone(f);
879	>	checkCompletedNormally(g, 34);
880		return NoResult;
881	<	}
759	<	};
881	>	}};
882		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
883		}
884
#	Line 765 | Line 887 | public class RecursiveTaskTest extends J
887		* there are more tasks than threads
888		*/
889		public void testGetSurplusQueuedTaskCount() {
890	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
891	<	public Integer compute() {
890	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
891	>	public Integer realCompute() {
892		FibTask h = new FibTask(7);
893	<	threadAssertSame(h, h.fork());
893	>	assertSame(h, h.fork());
894		FibTask g = new FibTask(9);
895	<	threadAssertSame(g, g.fork());
895	>	assertSame(g, g.fork());
896		FibTask f = new FibTask(8);
897	<	threadAssertSame(f, f.fork());
898	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
897	>	assertSame(f, f.fork());
898	>	assertTrue(getSurplusQueuedTaskCount() > 0);
899		helpQuiesce();
900	+	assertEquals(0, getSurplusQueuedTaskCount());
901	+	checkCompletedNormally(f, 21);
902	+	checkCompletedNormally(g, 34);
903	+	checkCompletedNormally(h, 13);
904		return NoResult;
905	<	}
780	<	};
905	>	}};
906		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
907		}
908
#	Line 785 | Line 910 | public class RecursiveTaskTest extends J
910		* peekNextLocalTask returns most recent unexecuted task.
911		*/
912		public void testPeekNextLocalTask() {
913	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
914	<	public Integer compute() {
913	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
914	>	public Integer realCompute() {
915		FibTask g = new FibTask(9);
916	<	threadAssertSame(g, g.fork());
916	>	assertSame(g, g.fork());
917		FibTask f = new FibTask(8);
918	<	threadAssertSame(f, f.fork());
919	<	threadAssertTrue(peekNextLocalTask() == f);
920	<	threadAssertTrue(f.join() == 21);
796	<	threadAssertTrue(f.isDone());
918	>	assertSame(f, f.fork());
919	>	assertSame(f, peekNextLocalTask());
920	>	checkCompletesNormally(f, 21);
921		helpQuiesce();
922	+	checkCompletedNormally(g, 34);
923		return NoResult;
924	<	}
800	<	};
924	>	}};
925		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
926		}
927
#	Line 806 | Line 930 | public class RecursiveTaskTest extends J
930		* without executing it
931		*/
932		public void testPollNextLocalTask() {
933	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
934	<	public Integer compute() {
933	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
934	>	public Integer realCompute() {
935		FibTask g = new FibTask(9);
936	<	threadAssertSame(g, g.fork());
936	>	assertSame(g, g.fork());
937		FibTask f = new FibTask(8);
938	<	threadAssertSame(f, f.fork());
939	<	threadAssertTrue(pollNextLocalTask() == f);
938	>	assertSame(f, f.fork());
939	>	assertSame(f, pollNextLocalTask());
940		helpQuiesce();
941	<	threadAssertFalse(f.isDone());
941	>	checkNotDone(f);
942	>	checkCompletedNormally(g, 34);
943		return NoResult;
944	<	}
820	<	};
944	>	}};
945		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
946		}
947
#	Line 825 | Line 949 | public class RecursiveTaskTest extends J
949		* pollTask returns an unexecuted task without executing it
950		*/
951		public void testPollTask() {
952	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
953	<	public Integer compute() {
952	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
953	>	public Integer realCompute() {
954		FibTask g = new FibTask(9);
955	<	threadAssertSame(g, g.fork());
955	>	assertSame(g, g.fork());
956		FibTask f = new FibTask(8);
957	<	threadAssertSame(f, f.fork());
958	<	threadAssertTrue(pollTask() == f);
957	>	assertSame(f, f.fork());
958	>	assertSame(f, pollTask());
959		helpQuiesce();
960	<	threadAssertFalse(f.isDone());
961	<	threadAssertTrue(g.isDone());
960	>	checkNotDone(f);
961	>	checkCompletedNormally(g, 34);
962		return NoResult;
963	<	}
840	<	};
963	>	}};
964		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
965		}
966
#	Line 845 | Line 968 | public class RecursiveTaskTest extends J
968		* peekNextLocalTask returns least recent unexecuted task in async mode
969		*/
970		public void testPeekNextLocalTaskAsync() {
971	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
972	<	public Integer compute() {
971	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
972	>	public Integer realCompute() {
973		FibTask g = new FibTask(9);
974	<	threadAssertSame(g, g.fork());
974	>	assertSame(g, g.fork());
975		FibTask f = new FibTask(8);
976	<	threadAssertSame(f, f.fork());
977	<	threadAssertTrue(peekNextLocalTask() == g);
978	<	threadAssertEquals(21, (int) f.join());
976	>	assertSame(f, f.fork());
977	>	assertSame(g, peekNextLocalTask());
978	>	assertEquals(21, (int) f.join());
979		helpQuiesce();
980	<	threadAssertTrue(f.isDone());
980	>	checkCompletedNormally(f, 21);
981	>	checkCompletedNormally(g, 34);
982		return NoResult;
983	<	}
860	<	};
983	>	}};
984		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
985		}
986
987		/**
988	<	* pollNextLocalTask returns least recent unexecuted task
989	<	* without executing it, in async mode
988	>	* pollNextLocalTask returns least recent unexecuted task without
989	>	* executing it, in async mode
990		*/
991		public void testPollNextLocalTaskAsync() {
992	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
993	<	public Integer compute() {
992	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
993	>	public Integer realCompute() {
994		FibTask g = new FibTask(9);
995	<	threadAssertSame(g, g.fork());
995	>	assertSame(g, g.fork());
996		FibTask f = new FibTask(8);
997	<	threadAssertSame(f, f.fork());
998	<	threadAssertTrue(pollNextLocalTask() == g);
997	>	assertSame(f, f.fork());
998	>	assertSame(g, pollNextLocalTask());
999		helpQuiesce();
1000	<	threadAssertTrue(f.isDone());
1001	<	threadAssertFalse(g.isDone());
1000	>	checkCompletedNormally(f, 21);
1001	>	checkNotDone(g);
1002		return NoResult;
1003	<	}
881	<	};
1003	>	}};
1004		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
1005		}
1006
1007		/**
1008	<	* pollTask returns an unexecuted task
1009	<	* without executing it, in async mode
1008	>	* pollTask returns an unexecuted task without executing it, in
1009	>	* async mode
1010		*/
1011		public void testPollTaskAsync() {
1012	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
1013	<	public Integer compute() {
1012	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
1013	>	public Integer realCompute() {
1014		FibTask g = new FibTask(9);
1015	<	threadAssertSame(g, g.fork());
1015	>	assertSame(g, g.fork());
1016		FibTask f = new FibTask(8);
1017	<	threadAssertSame(f, f.fork());
1018	<	threadAssertTrue(pollTask() == g);
1017	>	assertSame(f, f.fork());
1018	>	assertSame(g, pollTask());
1019		helpQuiesce();
1020	<	threadAssertTrue(f.isDone());
1021	<	threadAssertFalse(g.isDone());
1020	>	checkCompletedNormally(f, 21);
1021	>	checkNotDone(g);
1022		return NoResult;
1023	<	}
902	<	};
1023	>	}};
1024		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
1025		}
1026

Diff Legend

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