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.17 by dl, Tue Sep 14 10:24:07 2010 UTC vs.
Revision 1.36 by jsr166, Mon May 29 19:15:02 2017 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9	>	import java.util.HashSet;
10		import java.util.concurrent.CancellationException;
11		import java.util.concurrent.ExecutionException;
12		import java.util.concurrent.ForkJoinPool;
13	+	import java.util.concurrent.ForkJoinTask;
14		import java.util.concurrent.RecursiveTask;
15	<	import java.util.concurrent.TimeUnit;
16	<	import java.util.HashSet;
15	>	import java.util.concurrent.TimeoutException;
16	>
17	>	import junit.framework.Test;
18	>	import junit.framework.TestSuite;
19
20		public class RecursiveTaskTest extends JSR166TestCase {
21
22		public static void main(String[] args) {
23	<	junit.textui.TestRunner.run(suite());
23	>	main(suite(), args);
24		}
25		public static Test suite() {
26		return new TestSuite(RecursiveTaskTest.class);
#	Line 36 | Line 41 | public class RecursiveTaskTest extends J
41		}
42
43		private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
44	+	try (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(randomTimeout(), randomTimeUnit());
73	+	shouldThrow();
74	+	} catch (InterruptedException success) {
75	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
76	+	}
77	+
78	+	try {
79	+	a.get(randomExpiredTimeout(), randomTimeUnit());
80	+	shouldThrow();
81	+	} catch (TimeoutException success) {
82	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
83	+	}
84	+
85	+	<T> void checkCompletedNormally(RecursiveTask<T> a, T 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	+	assertSame(expected, a.get(randomTimeout(), randomTimeUnit()));
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	<	return pool.invoke(a);
131	<	} finally {
132	<	joinPool(pool);
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(randomTimeout(), randomTimeUnit());
143	>	shouldThrow();
144	>	} catch (CancellationException success) {
145	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
146	>	}
147	>
148	>	void checkCompletedAbnormally(RecursiveTask a, Throwable t) {
149	>	assertTrue(a.isDone());
150	>	assertFalse(a.isCancelled());
151	>	assertFalse(a.isCompletedNormally());
152	>	assertTrue(a.isCompletedAbnormally());
153	>	assertSame(t.getClass(), a.getException().getClass());
154	>	assertNull(a.getRawResult());
155	>	assertFalse(a.cancel(false));
156	>	assertFalse(a.cancel(true));
157	>
158	>	try {
159	>	a.join();
160	>	shouldThrow();
161	>	} catch (Throwable expected) {
162	>	assertSame(t.getClass(), expected.getClass());
163		}
164	+
165	+	try {
166	+	a.get();
167	+	shouldThrow();
168	+	} catch (ExecutionException success) {
169	+	assertSame(t.getClass(), success.getCause().getClass());
170	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
171	+
172	+	try {
173	+	a.get(randomTimeout(), randomTimeUnit());
174	+	shouldThrow();
175	+	} catch (ExecutionException success) {
176	+	assertSame(t.getClass(), success.getCause().getClass());
177	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
178		}
179
180	<	static final class FJException extends RuntimeException {
181	<	FJException() { super(); }
180	>	public static final class FJException extends RuntimeException {
181	>	public FJException() { super(); }
182		}
183
184	<	// An invalid return value for Fib
184	>	/** An invalid return value for Fib. */
185		static final Integer NoResult = Integer.valueOf(-17);
186
187	<	// A simple recursive task for testing
188	<	static final class FibTask extends RecursiveTask<Integer> {
187	>	/** A simple recursive task for testing. */
188	>	final class FibTask extends CheckedRecursiveTask<Integer> {
189		final int number;
190		FibTask(int n) { number = n; }
191	<	public Integer compute() {
191	>	public Integer realCompute() {
192		int n = number;
193		if (n <= 1)
194		return n;
#	Line 62 | Line 196 | public class RecursiveTaskTest extends J
196		f1.fork();
197		return (new FibTask(n - 2)).compute() + f1.join();
198		}
199	+
200	+	public void publicSetRawResult(Integer result) {
201	+	setRawResult(result);
202	+	}
203		}
204
205	<	// A recursive action failing in base case
206	<	static final class FailingFibTask extends RecursiveTask<Integer> {
205	>	/** A recursive action failing in base case. */
206	>	final class FailingFibTask extends RecursiveTask<Integer> {
207		final int number;
208		int result;
209		FailingFibTask(int n) { number = n; }
#	Line 86 | Line 224 | public class RecursiveTaskTest extends J
224		* returns value;
225		*/
226		public void testInvoke() {
227	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
228	<	public Integer compute() {
227	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
228	>	public Integer realCompute() {
229		FibTask f = new FibTask(8);
230		Integer r = f.invoke();
231	<	threadAssertTrue(r == 21);
232	<	threadAssertTrue(f.isDone());
95	<	threadAssertFalse(f.isCancelled());
96	<	threadAssertFalse(f.isCompletedAbnormally());
97	<	threadAssertTrue(f.getRawResult() == 21);
231	>	assertEquals(21, (int) r);
232	>	checkCompletedNormally(f, r);
233		return r;
234	<	}
100	<	};
234	>	}};
235		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
236		}
237
#	Line 107 | Line 241 | public class RecursiveTaskTest extends J
241		* completed tasks
242		*/
243		public void testQuietlyInvoke() {
244	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
245	<	public Integer compute() {
244	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
245	>	public Integer realCompute() {
246		FibTask f = new FibTask(8);
247		f.quietlyInvoke();
248	<	Integer r = f.getRawResult();
249	<	threadAssertTrue(r == 21);
250	<	threadAssertTrue(f.isDone());
251	<	threadAssertFalse(f.isCancelled());
118	<	threadAssertFalse(f.isCompletedAbnormally());
119	<	return r;
120	<	}
121	<	};
122	<	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
248	>	checkCompletedNormally(f, 21);
249	>	return NoResult;
250	>	}};
251	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
252		}
253
254		/**
255		* join of a forked task returns when task completes
256		*/
257		public void testForkJoin() {
258	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
259	<	public Integer compute() {
258	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
259	>	public Integer realCompute() {
260		FibTask f = new FibTask(8);
261	<	threadAssertSame(f, f.fork());
261	>	assertSame(f, f.fork());
262		Integer r = f.join();
263	<	threadAssertTrue(r == 21);
264	<	threadAssertTrue(f.isDone());
263	>	assertEquals(21, (int) r);
264	>	checkCompletedNormally(f, r);
265		return r;
266	<	}
138	<	};
266	>	}};
267		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
268		}
269
#	Line 143 | Line 271 | public class RecursiveTaskTest extends J
271		* get of a forked task returns when task completes
272		*/
273		public void testForkGet() {
274	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
275	<	public Integer compute() {
276	<	try {
277	<	FibTask f = new FibTask(8);
278	<	threadAssertSame(f, f.fork());
279	<	Integer r = f.get();
280	<	threadAssertTrue(r == 21);
281	<	threadAssertTrue(f.isDone());
282	<	return r;
155	<	} catch (Exception ex) {
156	<	unexpectedException(ex);
157	<	}
158	<	return NoResult;
159	<	}
160	<	};
274	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
275	>	public Integer realCompute() throws Exception {
276	>	FibTask f = new FibTask(8);
277	>	assertSame(f, f.fork());
278	>	Integer r = f.get();
279	>	assertEquals(21, (int) r);
280	>	checkCompletedNormally(f, r);
281	>	return r;
282	>	}};
283		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
284		}
285
#	Line 165 | Line 287 | public class RecursiveTaskTest extends J
287		* timed get of a forked task returns when task completes
288		*/
289		public void testForkTimedGet() {
290	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
291	<	public Integer compute() {
292	<	try {
293	<	FibTask f = new FibTask(8);
294	<	threadAssertSame(f, f.fork());
295	<	Integer r = f.get(5L, TimeUnit.SECONDS);
296	<	threadAssertTrue(r == 21);
297	<	threadAssertTrue(f.isDone());
298	<	return r;
177	<	} catch (Exception ex) {
178	<	unexpectedException(ex);
179	<	}
180	<	return NoResult;
181	<	}
182	<	};
290	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
291	>	public Integer realCompute() throws Exception {
292	>	FibTask f = new FibTask(8);
293	>	assertSame(f, f.fork());
294	>	Integer r = f.get(LONG_DELAY_MS, MILLISECONDS);
295	>	assertEquals(21, (int) r);
296	>	checkCompletedNormally(f, r);
297	>	return r;
298	>	}};
299		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
300		}
301
#	Line 187 | Line 303 | public class RecursiveTaskTest extends J
303		* quietlyJoin of a forked task returns when task completes
304		*/
305		public void testForkQuietlyJoin() {
306	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
307	<	public Integer compute() {
306	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
307	>	public Integer realCompute() {
308		FibTask f = new FibTask(8);
309	<	threadAssertSame(f, f.fork());
309	>	assertSame(f, f.fork());
310		f.quietlyJoin();
311		Integer r = f.getRawResult();
312	<	threadAssertTrue(r == 21);
313	<	threadAssertTrue(f.isDone());
312	>	assertEquals(21, (int) r);
313	>	checkCompletedNormally(f, r);
314		return r;
315	<	}
200	<	};
315	>	}};
316		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
317		}
318
204	–
319		/**
320		* helpQuiesce returns when tasks are complete.
321		* getQueuedTaskCount returns 0 when quiescent
322		*/
323		public void testForkHelpQuiesce() {
324	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
325	<	public Integer compute() {
324	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
325	>	public Integer realCompute() {
326		FibTask f = new FibTask(8);
327	<	threadAssertSame(f, f.fork());
328	<	f.helpQuiesce();
329	<	Integer r = f.getRawResult();
330	<	threadAssertTrue(r == 21);
331	<	threadAssertTrue(f.isDone());
332	<	threadAssertTrue(getQueuedTaskCount() == 0);
333	<	return r;
334	<	}
335	<	};
222	<	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
327	>	assertSame(f, f.fork());
328	>	helpQuiesce();
329	>	while (!f.isDone()) // wait out race
330	>	;
331	>	assertEquals(0, getQueuedTaskCount());
332	>	checkCompletedNormally(f, 21);
333	>	return NoResult;
334	>	}};
335	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
336		}
337
225	–
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 {
233	–	FailingFibTask f = new FailingFibTask(8);
346		f.invoke();
347		shouldThrow();
236	–	return NoResult;
348		} catch (FJException success) {
349	+	checkCompletedAbnormally(f, success);
350		}
351		return NoResult;
352	<	}
241	<	};
352	>	}};
353		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
354		}
355
#	Line 246 | Line 357 | public class RecursiveTaskTest extends J
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	<	}
256	<	};
367	>	}};
368		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
369		}
370
#	Line 261 | Line 372 | public class RecursiveTaskTest extends J
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 {
267	–	FailingFibTask f = new FailingFibTask(8);
268	–	threadAssertSame(f, f.fork());
380		Integer r = f.join();
381		shouldThrow();
271	–	return r;
382		} catch (FJException success) {
383	+	checkCompletedAbnormally(f, success);
384		}
385		return NoResult;
386	<	}
276	<	};
386	>	}};
387		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
388		}
389
#	Line 281 | Line 391 | public class RecursiveTaskTest extends J
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 {
287	–	FailingFibTask f = new FailingFibTask(8);
288	–	threadAssertSame(f, f.fork());
399		Integer r = f.get();
400		shouldThrow();
291	–	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	<	}
298	<	};
407	>	}};
408		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
409		}
410
#	Line 303 | Line 412 | public class RecursiveTaskTest extends J
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);
310	<	threadAssertSame(f, f.fork());
311	<	Integer r = f.get(5L, TimeUnit.SECONDS);
420	>	Integer r = f.get(LONG_DELAY_MS, MILLISECONDS);
421		shouldThrow();
313	–	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	<	}
320	<	};
428	>	}};
429		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
430		}
431
#	Line 325 | Line 433 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, f.fork());
439	>	assertSame(f, f.fork());
440		f.quietlyJoin();
441	<	threadAssertTrue(f.isDone());
442	<	threadAssertTrue(f.isCompletedAbnormally());
335	<	threadAssertTrue(f.getException() instanceof FJException);
441	>	assertTrue(f.getException() instanceof FJException);
442	>	checkCompletedAbnormally(f, f.getException());
443		return NoResult;
444	<	}
338	<	};
444	>	}};
445		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
446		}
447
#	Line 343 | Line 449 | public class RecursiveTaskTest extends J
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 {
349	–	FibTask f = new FibTask(8);
350	–	threadAssertTrue(f.cancel(true));
457		Integer r = f.invoke();
458		shouldThrow();
353	–	return r;
459		} catch (CancellationException success) {
460	+	checkCancelled(f);
461		}
462		return NoResult;
463	<	}
358	<	};
463	>	}};
464		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
465		}
466
#	Line 363 | Line 468 | public class RecursiveTaskTest extends J
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 {
369	–	FibTask f = new FibTask(8);
370	–	threadAssertTrue(f.cancel(true));
371	–	threadAssertSame(f, f.fork());
477		Integer r = f.join();
478		shouldThrow();
374	–	return r;
479		} catch (CancellationException success) {
480	+	checkCancelled(f);
481		}
482		return NoResult;
483	<	}
379	<	};
483	>	}};
484		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
485		}
486
#	Line 384 | Line 488 | public class RecursiveTaskTest extends J
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 {
390	–	FibTask f = new FibTask(8);
391	–	threadAssertTrue(f.cancel(true));
392	–	threadAssertSame(f, f.fork());
497		Integer r = f.get();
498		shouldThrow();
395	–	return r;
499		} catch (CancellationException success) {
500	<	} catch (Exception ex) {
398	<	unexpectedException(ex);
500	>	checkCancelled(f);
501		}
502		return NoResult;
503	<	}
402	<	};
503	>	}};
504		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
505		}
506
#	Line 407 | Line 508 | public class RecursiveTaskTest extends J
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);
414	<	threadAssertTrue(f.cancel(true));
415	<	threadAssertSame(f, f.fork());
416	<	Integer r = f.get(5L, TimeUnit.SECONDS);
517	>	Integer r = f.get(LONG_DELAY_MS, MILLISECONDS);
518		shouldThrow();
418	–	return r;
519		} catch (CancellationException success) {
520	<	} catch (Exception ex) {
421	<	unexpectedException(ex);
520	>	checkCancelled(f);
521		}
522		return NoResult;
523	<	}
425	<	};
523	>	}};
524		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
525		}
526
#	Line 430 | Line 528 | public class RecursiveTaskTest extends J
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	<	threadAssertTrue(f.cancel(true));
535	<	threadAssertSame(f, f.fork());
534	>	assertTrue(f.cancel(true));
535	>	assertSame(f, f.fork());
536		f.quietlyJoin();
537	<	threadAssertTrue(f.isDone());
440	<	threadAssertTrue(f.isCompletedAbnormally());
441	<	threadAssertTrue(f.getException() instanceof CancellationException);
537	>	checkCancelled(f);
538		return NoResult;
539	<	}
444	<	};
539	>	}};
540		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
541		}
542
#	Line 450 | Line 545 | public class RecursiveTaskTest extends J
545		*/
546		public void testGetPool() {
547		final ForkJoinPool mainPool = mainPool();
548	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
549	<	public Integer compute() {
550	<	threadAssertTrue(getPool() == mainPool);
548	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
549	>	public Integer realCompute() {
550	>	assertSame(mainPool, getPool());
551		return NoResult;
552	<	}
458	<	};
552	>	}};
553		assertSame(NoResult, testInvokeOnPool(mainPool, a));
554		}
555
#	Line 463 | Line 557 | public class RecursiveTaskTest extends J
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	<	}
471	<	};
564	>	}};
565		assertSame(NoResult, a.invoke());
566		}
567
#	Line 476 | Line 569 | public class RecursiveTaskTest extends J
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	<	}
484	<	};
576	>	}};
577		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
578		}
579
#	Line 489 | Line 581 | public class RecursiveTaskTest extends J
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	<	}
497	<	};
588	>	}};
589		assertSame(NoResult, a.invoke());
590		}
591
#	Line 502 | Line 593 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(getRawResult(), NoResult);
599	>	assertSame(NoResult, getRawResult());
600		return NoResult;
601		}
602		};
603	<	a.invoke();
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	<	};
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
#	Line 537 | Line 653 | public class RecursiveTaskTest extends J
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 {
543	–	FibTask f = new FibTask(8);
544	–	f.completeExceptionally(new FJException());
661		Integer r = f.invoke();
662		shouldThrow();
547	–	return r;
663		} catch (FJException success) {
664	+	checkCompletedAbnormally(f, success);
665		}
666		return NoResult;
667	<	}
552	<	};
667	>	}};
668		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
669		}
670
#	Line 557 | Line 672 | public class RecursiveTaskTest extends J
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	<	}
569	<	};
683	>	}};
684		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
685		}
686
#	Line 574 | Line 688 | public class RecursiveTaskTest extends J
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);
584	<	threadAssertTrue(g.isDone());
585	<	threadAssertTrue(g.join() == 34);
696	>	checkCompletedNormally(f, 21);
697	>	checkCompletedNormally(g, 34);
698		return NoResult;
699	<	}
588	<	};
699	>	}};
700		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
701		}
702
#	Line 593 | Line 704 | public class RecursiveTaskTest extends J
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());
601	<	threadAssertTrue(f.join() == 21);
711	>	checkCompletedNormally(f, 21);
712		return NoResult;
713	<	}
604	<	};
713	>	}};
714		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
715		}
716
#	Line 609 | Line 718 | public class RecursiveTaskTest extends J
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	<	}
626	<	};
734	>	}};
735		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
736		}
737
#	Line 631 | Line 739 | public class RecursiveTaskTest extends J
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 641 | 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	<	}
652	<	};
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 {
664	–	FibTask f = new FibTask(8);
665	–	FailingFibTask g = new FailingFibTask(9);
790		invokeAll(f, g);
791		shouldThrow();
668	–	return NoResult;
792		} catch (FJException success) {
793	+	checkCompletedAbnormally(g, success);
794		}
795		return NoResult;
796	<	}
673	<	};
796	>	}};
797		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
798		}
799
#	Line 678 | Line 801 | public class RecursiveTaskTest extends J
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 {
684	–	FailingFibTask g = new FailingFibTask(9);
808		invokeAll(g);
809		shouldThrow();
687	–	return NoResult;
810		} catch (FJException success) {
811	+	checkCompletedAbnormally(g, success);
812		}
813		return NoResult;
814	<	}
692	<	};
814	>	}};
815		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
816		}
817
#	Line 697 | Line 819 | public class RecursiveTaskTest extends J
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 {
703	–	FibTask f = new FibTask(8);
704	–	FailingFibTask g = new FailingFibTask(9);
705	–	FibTask h = new FibTask(7);
828		invokeAll(f, g, h);
829		shouldThrow();
708	–	return NoResult;
830		} catch (FJException success) {
831	+	checkCompletedAbnormally(g, success);
832		}
833		return NoResult;
834	<	}
713	<	};
834	>	}};
835		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
836		}
837
#	Line 718 | Line 839 | public class RecursiveTaskTest extends J
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 {
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);
852		invokeAll(set);
853		shouldThrow();
733	–	return NoResult;
854		} catch (FJException success) {
855	+	checkCompletedAbnormally(f, success);
856		}
857		return NoResult;
858	<	}
738	<	};
858	>	}};
859		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
860		}
861
#	Line 744 | 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	<	threadAssertSame(g, g.fork());
870	>	assertSame(g, g.fork());
871		FibTask f = new FibTask(8);
872	<	threadAssertSame(f, 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	<	}
759	<	};
878	>	}};
879		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
880		}
881
#	Line 765 | 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	<	threadAssertSame(h, h.fork());
890	>	assertSame(h, h.fork());
891		FibTask g = new FibTask(9);
892	<	threadAssertSame(g, g.fork());
892	>	assertSame(g, g.fork());
893		FibTask f = new FibTask(8);
894	<	threadAssertSame(f, 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	<	}
780	<	};
902	>	}};
903		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
904		}
905
#	Line 785 | Line 907 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(g, g.fork());
913	>	assertSame(g, g.fork());
914		FibTask f = new FibTask(8);
915	<	threadAssertSame(f, f.fork());
916	<	threadAssertTrue(peekNextLocalTask() == f);
917	<	threadAssertTrue(f.join() == 21);
796	<	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	<	}
800	<	};
921	>	}};
922		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
923		}
924
#	Line 806 | 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	<	threadAssertSame(g, g.fork());
933	>	assertSame(g, g.fork());
934		FibTask f = new FibTask(8);
935	<	threadAssertSame(f, 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	<	}
820	<	};
941	>	}};
942		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
943		}
944
#	Line 825 | Line 946 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(g, g.fork());
952	>	assertSame(g, g.fork());
953		FibTask f = new FibTask(8);
954	<	threadAssertSame(f, 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	<	}
840	<	};
960	>	}};
961		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
962		}
963
#	Line 845 | Line 965 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(g, g.fork());
971	>	assertSame(g, g.fork());
972		FibTask f = new FibTask(8);
973	<	threadAssertSame(f, f.fork());
974	<	threadAssertTrue(peekNextLocalTask() == g);
975	<	threadAssertEquals(21, (int) 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	<	}
860	<	};
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	<	threadAssertSame(g, g.fork());
992	>	assertSame(g, g.fork());
993		FibTask f = new FibTask(8);
994	<	threadAssertSame(f, 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	<	}
881	<	};
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	<	threadAssertSame(g, g.fork());
1012	>	assertSame(g, g.fork());
1013		FibTask f = new FibTask(8);
1014	<	threadAssertSame(f, 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	<	}
902	<	};
1020	>	}};
1021		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
1022		}
1023

Diff Legend

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