ViewVC Help

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

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

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

Diff Legend

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