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.6 by jsr166, Tue Aug 4 10:13:48 2009 UTC vs.
Revision 1.31 by jsr166, Fri May 27 19:13:51 2011 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6	–	import junit.framework.*;
7	–	import java.util.concurrent.*;
8	–	import java.util.*;
6
7	+	import junit.framework.*;
8	+	import java.util.concurrent.CancellationException;
9	+	import java.util.concurrent.SynchronousQueue;
10	+	import java.util.concurrent.ExecutionException;
11	+	import java.util.concurrent.ForkJoinPool;
12	+	import java.util.concurrent.ForkJoinTask;
13	+	import java.util.concurrent.ForkJoinWorkerThread;
14	+	import java.util.concurrent.RecursiveAction;
15	+	import java.util.concurrent.TimeUnit;
16	+	import java.util.concurrent.TimeoutException;
17	+	import static java.util.concurrent.TimeUnit.SECONDS;
18	+	import java.util.HashSet;
19
20		public class RecursiveActionTest extends JSR166TestCase {
21
22		public static void main(String[] args) {
23	<	junit.textui.TestRunner.run (suite());
23	>	junit.textui.TestRunner.run(suite());
24		}
25	+
26		public static Test suite() {
27	<	return new TestSuite(RecursiveActionTest.class);
27	>	return new TestSuite(RecursiveActionTest.class);
28	>	}
29	>
30	>	private static ForkJoinPool mainPool() {
31	>	return new ForkJoinPool();
32	>	}
33	>
34	>	private static ForkJoinPool singletonPool() {
35	>	return new ForkJoinPool(1);
36		}
37
38	<	static final ForkJoinPool mainPool = new ForkJoinPool();
39	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
40	<	static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
41	<	static {
24	<	asyncSingletonPool.setAsyncMode(true);
38	>	private static ForkJoinPool asyncSingletonPool() {
39	>	return new ForkJoinPool(1,
40	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
41	>	null, true);
42		}
43
44	<	static final class FJException extends RuntimeException {
45	<	FJException() { super(); }
44	>	private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
45	>	try {
46	>	checkNotDone(a);
47	>
48	>	assertNull(pool.invoke(a));
49	>
50	>	checkCompletedNormally(a);
51	>	} finally {
52	>	joinPool(pool);
53	>	}
54	>	}
55	>
56	>	void checkNotDone(RecursiveAction a) {
57	>	assertFalse(a.isDone());
58	>	assertFalse(a.isCompletedNormally());
59	>	assertFalse(a.isCompletedAbnormally());
60	>	assertFalse(a.isCancelled());
61	>	assertNull(a.getException());
62	>	assertNull(a.getRawResult());
63	>
64	>	if (! ForkJoinTask.inForkJoinPool()) {
65	>	Thread.currentThread().interrupt();
66	>	try {
67	>	a.get();
68	>	shouldThrow();
69	>	} catch (InterruptedException success) {
70	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
71	>
72	>	Thread.currentThread().interrupt();
73	>	try {
74	>	a.get(5L, SECONDS);
75	>	shouldThrow();
76	>	} catch (InterruptedException success) {
77	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
78	>	}
79	>
80	>	try {
81	>	a.get(0L, SECONDS);
82	>	shouldThrow();
83	>	} catch (TimeoutException success) {
84	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
85	>	}
86	>
87	>	void checkCompletedNormally(RecursiveAction a) {
88	>	assertTrue(a.isDone());
89	>	assertFalse(a.isCancelled());
90	>	assertTrue(a.isCompletedNormally());
91	>	assertFalse(a.isCompletedAbnormally());
92	>	assertNull(a.getException());
93	>	assertNull(a.getRawResult());
94	>	assertNull(a.join());
95	>	assertFalse(a.cancel(false));
96	>	assertFalse(a.cancel(true));
97	>	try {
98	>	assertNull(a.get());
99	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
100	>	try {
101	>	assertNull(a.get(5L, SECONDS));
102	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
103	>	}
104	>
105	>	void checkCancelled(RecursiveAction a) {
106	>	assertTrue(a.isDone());
107	>	assertTrue(a.isCancelled());
108	>	assertFalse(a.isCompletedNormally());
109	>	assertTrue(a.isCompletedAbnormally());
110	>	assertTrue(a.getException() instanceof CancellationException);
111	>	assertNull(a.getRawResult());
112	>
113	>	try {
114	>	a.join();
115	>	shouldThrow();
116	>	} catch (CancellationException success) {
117	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
118	>
119	>	try {
120	>	a.get();
121	>	shouldThrow();
122	>	} catch (CancellationException success) {
123	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
124	>
125	>	try {
126	>	a.get(5L, SECONDS);
127	>	shouldThrow();
128	>	} catch (CancellationException success) {
129	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
130	>	}
131	>
132	>	void checkCompletedAbnormally(RecursiveAction a, Throwable t) {
133	>	assertTrue(a.isDone());
134	>	assertFalse(a.isCancelled());
135	>	assertFalse(a.isCompletedNormally());
136	>	assertTrue(a.isCompletedAbnormally());
137	>	assertSame(t.getClass(), a.getException().getClass());
138	>	assertNull(a.getRawResult());
139	>	assertFalse(a.cancel(false));
140	>	assertFalse(a.cancel(true));
141	>
142	>	try {
143	>	a.join();
144	>	shouldThrow();
145	>	} catch (Throwable expected) {
146	>	assertSame(expected.getClass(), t.getClass());
147	>	}
148	>
149	>	try {
150	>	a.get();
151	>	shouldThrow();
152	>	} catch (ExecutionException success) {
153	>	assertSame(t.getClass(), success.getCause().getClass());
154	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
155	>
156	>	try {
157	>	a.get(5L, SECONDS);
158	>	shouldThrow();
159	>	} catch (ExecutionException success) {
160	>	assertSame(t.getClass(), success.getCause().getClass());
161	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
162	>	}
163	>
164	>	public static final class FJException extends RuntimeException {
165	>	public FJException() { super(); }
166	>	public FJException(Throwable cause) { super(cause); }
167		}
168
169		// A simple recursive action for testing
170	<	static final class FibAction extends RecursiveAction {
170	>	final class FibAction extends CheckedRecursiveAction {
171		final int number;
172		int result;
173		FibAction(int n) { number = n; }
174	<	public void compute() {
174	>	public void realCompute() {
175		int n = number;
176		if (n <= 1)
177		result = n;
#	Line 68 | Line 206 | public class RecursiveActionTest extends
206		* invoke returns when task completes normally.
207		* isCompletedAbnormally and isCancelled return false for normally
208		* completed tasks. getRawResult of a RecursiveAction returns null;
71	–	*
209		*/
210		public void testInvoke() {
211	<	RecursiveAction a = new RecursiveAction() {
212	<	public void compute() {
213	<	FibAction f = new FibAction(8);
214	<	f.invoke();
215	<	threadAssertTrue(f.result == 21);
216	<	threadAssertTrue(f.isDone());
217	<	threadAssertFalse(f.isCancelled());
218	<	threadAssertFalse(f.isCompletedAbnormally());
82	<	threadAssertTrue(f.getRawResult() == null);
83	<	}
84	<	};
85	<	mainPool.invoke(a);
211	>	RecursiveAction a = new CheckedRecursiveAction() {
212	>	public void realCompute() {
213	>	FibAction f = new FibAction(8);
214	>	assertNull(f.invoke());
215	>	assertEquals(21, f.result);
216	>	checkCompletedNormally(f);
217	>	}};
218	>	testInvokeOnPool(mainPool(), a);
219		}
220
221		/**
#	Line 91 | Line 224 | public class RecursiveActionTest extends
224		* completed tasks
225		*/
226		public void testQuietlyInvoke() {
227	<	RecursiveAction a = new RecursiveAction() {
228	<	public void compute() {
229	<	FibAction f = new FibAction(8);
230	<	f.quietlyInvoke();
231	<	threadAssertTrue(f.result == 21);
232	<	threadAssertTrue(f.isDone());
233	<	threadAssertFalse(f.isCancelled());
234	<	threadAssertFalse(f.isCompletedAbnormally());
102	<	threadAssertTrue(f.getRawResult() == null);
103	<	}
104	<	};
105	<	mainPool.invoke(a);
227	>	RecursiveAction a = new CheckedRecursiveAction() {
228	>	public void realCompute() {
229	>	FibAction f = new FibAction(8);
230	>	f.quietlyInvoke();
231	>	assertEquals(21, f.result);
232	>	checkCompletedNormally(f);
233	>	}};
234	>	testInvokeOnPool(mainPool(), a);
235		}
236
237		/**
238		* join of a forked task returns when task completes
239		*/
240		public void testForkJoin() {
241	<	RecursiveAction a = new RecursiveAction() {
242	<	public void compute() {
243	<	FibAction f = new FibAction(8);
244	<	f.fork();
241	>	RecursiveAction a = new CheckedRecursiveAction() {
242	>	public void realCompute() {
243	>	FibAction f = new FibAction(8);
244	>	assertSame(f, f.fork());
245	>	assertNull(f.join());
246	>	assertEquals(21, f.result);
247	>	checkCompletedNormally(f);
248	>	}};
249	>	testInvokeOnPool(mainPool(), a);
250	>	}
251	>
252	>	/**
253	>	* join/quietlyJoin of a forked task succeeds in the presence of interrupts
254	>	*/
255	>	public void testJoinIgnoresInterrupts() {
256	>	RecursiveAction a = new CheckedRecursiveAction() {
257	>	public void realCompute() {
258	>	FibAction f = new FibAction(8);
259	>	final Thread myself = Thread.currentThread();
260	>
261	>	// test join()
262	>	assertSame(f, f.fork());
263	>	myself.interrupt();
264	>	assertTrue(myself.isInterrupted());
265	>	assertNull(f.join());
266	>	Thread.interrupted();
267	>	assertEquals(21, f.result);
268	>	checkCompletedNormally(f);
269	>
270	>	f.reinitialize();
271	>	f.cancel(true);
272	>	assertSame(f, f.fork());
273	>	myself.interrupt();
274	>	assertTrue(myself.isInterrupted());
275	>	try {
276	>	f.join();
277	>	shouldThrow();
278	>	} catch (CancellationException success) {
279	>	Thread.interrupted();
280	>	checkCancelled(f);
281	>	}
282	>
283	>	f.reinitialize();
284	>	f.completeExceptionally(new FJException());
285	>	assertSame(f, f.fork());
286	>	myself.interrupt();
287	>	assertTrue(myself.isInterrupted());
288	>	try {
289	>	f.join();
290	>	shouldThrow();
291	>	} catch (FJException success) {
292	>	Thread.interrupted();
293	>	checkCompletedAbnormally(f, success);
294	>	}
295	>
296	>	// test quietlyJoin()
297	>	f.reinitialize();
298	>	assertSame(f, f.fork());
299	>	myself.interrupt();
300	>	assertTrue(myself.isInterrupted());
301	>	f.quietlyJoin();
302	>	Thread.interrupted();
303	>	assertEquals(21, f.result);
304	>	checkCompletedNormally(f);
305	>
306	>	f.reinitialize();
307	>	f.cancel(true);
308	>	assertSame(f, f.fork());
309	>	myself.interrupt();
310	>	assertTrue(myself.isInterrupted());
311	>	f.quietlyJoin();
312	>	Thread.interrupted();
313	>	checkCancelled(f);
314	>
315	>	f.reinitialize();
316	>	f.completeExceptionally(new FJException());
317	>	assertSame(f, f.fork());
318	>	myself.interrupt();
319	>	assertTrue(myself.isInterrupted());
320	>	f.quietlyJoin();
321	>	Thread.interrupted();
322	>	checkCompletedAbnormally(f, f.getException());
323	>	}};
324	>	testInvokeOnPool(mainPool(), a);
325	>	a.reinitialize();
326	>	testInvokeOnPool(singletonPool(), a);
327	>	}
328	>
329	>	/**
330	>	* join/quietlyJoin of a forked task when not in ForkJoinPool
331	>	* succeeds in the presence of interrupts
332	>	*/
333	>	public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
334	>	final SynchronousQueue<FibAction[]> sq =
335	>	new SynchronousQueue<FibAction[]>();
336	>	RecursiveAction a = new CheckedRecursiveAction() {
337	>	public void realCompute() throws InterruptedException {
338	>	FibAction[] fibActions = new FibAction[6];
339	>	for (int i = 0; i < fibActions.length; i++)
340	>	fibActions[i] = new FibAction(8);
341	>
342	>	fibActions[1].cancel(false);
343	>	fibActions[2].completeExceptionally(new FJException());
344	>	fibActions[4].cancel(true);
345	>	fibActions[5].completeExceptionally(new FJException());
346	>
347	>	for (int i = 0; i < fibActions.length; i++)
348	>	fibActions[i].fork();
349	>
350	>	sq.put(fibActions);
351	>
352	>	helpQuiesce();
353	>	}};
354	>
355	>	Runnable r = new CheckedRunnable() {
356	>	public void realRun() throws InterruptedException {
357	>	FibAction[] fibActions = sq.take();
358	>	FibAction f;
359	>	final Thread myself = Thread.currentThread();
360	>
361	>	// test join() ------------
362	>
363	>	f = fibActions[0];
364	>	assertFalse(ForkJoinTask.inForkJoinPool());
365	>	myself.interrupt();
366	>	assertTrue(myself.isInterrupted());
367	>	assertNull(f.join());
368	>	assertTrue(Thread.interrupted());
369	>	assertEquals(21, f.result);
370	>	checkCompletedNormally(f);
371	>
372	>	f = fibActions[1];
373	>	myself.interrupt();
374	>	assertTrue(myself.isInterrupted());
375	>	try {
376		f.join();
377	<	threadAssertTrue(f.result == 21);
378	<	threadAssertTrue(f.isDone());
379	<	threadAssertTrue(f.getRawResult() == null);
377	>	shouldThrow();
378	>	} catch (CancellationException success) {
379	>	assertTrue(Thread.interrupted());
380	>	checkCancelled(f);
381		}
382	<	};
383	<	mainPool.invoke(a);
382	>
383	>	f = fibActions[2];
384	>	myself.interrupt();
385	>	assertTrue(myself.isInterrupted());
386	>	try {
387	>	f.join();
388	>	shouldThrow();
389	>	} catch (FJException success) {
390	>	assertTrue(Thread.interrupted());
391	>	checkCompletedAbnormally(f, success);
392	>	}
393	>
394	>	// test quietlyJoin() ---------
395	>
396	>	f = fibActions[3];
397	>	myself.interrupt();
398	>	assertTrue(myself.isInterrupted());
399	>	f.quietlyJoin();
400	>	assertTrue(Thread.interrupted());
401	>	assertEquals(21, f.result);
402	>	checkCompletedNormally(f);
403	>
404	>	f = fibActions[4];
405	>	myself.interrupt();
406	>	assertTrue(myself.isInterrupted());
407	>	f.quietlyJoin();
408	>	assertTrue(Thread.interrupted());
409	>	checkCancelled(f);
410	>
411	>	f = fibActions[5];
412	>	myself.interrupt();
413	>	assertTrue(myself.isInterrupted());
414	>	f.quietlyJoin();
415	>	assertTrue(Thread.interrupted());
416	>	assertTrue(f.getException() instanceof FJException);
417	>	checkCompletedAbnormally(f, f.getException());
418	>	}};
419	>
420	>	Thread t;
421	>
422	>	t = newStartedThread(r);
423	>	testInvokeOnPool(mainPool(), a);
424	>	awaitTermination(t, LONG_DELAY_MS);
425	>
426	>	a.reinitialize();
427	>	t = newStartedThread(r);
428	>	testInvokeOnPool(singletonPool(), a);
429	>	awaitTermination(t, LONG_DELAY_MS);
430		}
431
432		/**
433		* get of a forked task returns when task completes
434		*/
435		public void testForkGet() {
436	<	RecursiveAction a = new RecursiveAction() {
437	<	public void compute() {
438	<	try {
439	<	FibAction f = new FibAction(8);
440	<	f.fork();
441	<	f.get();
442	<	threadAssertTrue(f.result == 21);
443	<	threadAssertTrue(f.isDone());
444	<	} catch (Exception ex) {
138	<	unexpectedException(ex);
139	<	}
140	<	}
141	<	};
142	<	mainPool.invoke(a);
436	>	RecursiveAction a = new CheckedRecursiveAction() {
437	>	public void realCompute() throws Exception {
438	>	FibAction f = new FibAction(8);
439	>	assertSame(f, f.fork());
440	>	assertNull(f.get());
441	>	assertEquals(21, f.result);
442	>	checkCompletedNormally(f);
443	>	}};
444	>	testInvokeOnPool(mainPool(), a);
445		}
446
447		/**
448		* timed get of a forked task returns when task completes
449		*/
450		public void testForkTimedGet() {
451	<	RecursiveAction a = new RecursiveAction() {
452	<	public void compute() {
453	<	try {
454	<	FibAction f = new FibAction(8);
455	<	f.fork();
456	<	f.get(5L, TimeUnit.SECONDS);
457	<	threadAssertTrue(f.result == 21);
458	<	threadAssertTrue(f.isDone());
459	<	} catch (Exception ex) {
158	<	unexpectedException(ex);
159	<	}
160	<	}
161	<	};
162	<	mainPool.invoke(a);
451	>	RecursiveAction a = new CheckedRecursiveAction() {
452	>	public void realCompute() throws Exception {
453	>	FibAction f = new FibAction(8);
454	>	assertSame(f, f.fork());
455	>	assertNull(f.get(5L, SECONDS));
456	>	assertEquals(21, f.result);
457	>	checkCompletedNormally(f);
458	>	}};
459	>	testInvokeOnPool(mainPool(), a);
460		}
461
462		/**
463		* timed get with null time unit throws NPE
464		*/
465		public void testForkTimedGetNPE() {
466	<	RecursiveAction a = new RecursiveAction() {
467	<	public void compute() {
468	<	try {
469	<	FibAction f = new FibAction(8);
470	<	f.fork();
471	<	f.get(5L, null);
472	<	shouldThrow();
473	<	} catch (NullPointerException success) {
474	<	} catch (Exception ex) {
475	<	unexpectedException(ex);
179	<	}
180	<	}
181	<	};
182	<	mainPool.invoke(a);
183	<	}
184	<
185	<	/**
186	<	* helpJoin of a forked task returns when task completes
187	<	*/
188	<	public void testForkHelpJoin() {
189	<	RecursiveAction a = new RecursiveAction() {
190	<	public void compute() {
191	<	FibAction f = new FibAction(8);
192	<	f.fork();
193	<	f.helpJoin();
194	<	threadAssertTrue(f.result == 21);
195	<	threadAssertTrue(f.isDone());
196	<	}
197	<	};
198	<	mainPool.invoke(a);
466	>	RecursiveAction a = new CheckedRecursiveAction() {
467	>	public void realCompute() throws Exception {
468	>	FibAction f = new FibAction(8);
469	>	assertSame(f, f.fork());
470	>	try {
471	>	f.get(5L, null);
472	>	shouldThrow();
473	>	} catch (NullPointerException success) {}
474	>	}};
475	>	testInvokeOnPool(mainPool(), a);
476		}
477
478		/**
479		* quietlyJoin of a forked task returns when task completes
480		*/
481		public void testForkQuietlyJoin() {
482	<	RecursiveAction a = new RecursiveAction() {
483	<	public void compute() {
484	<	FibAction f = new FibAction(8);
485	<	f.fork();
486	<	f.quietlyJoin();
487	<	threadAssertTrue(f.result == 21);
488	<	threadAssertTrue(f.isDone());
489	<	}
490	<	};
214	<	mainPool.invoke(a);
482	>	RecursiveAction a = new CheckedRecursiveAction() {
483	>	public void realCompute() {
484	>	FibAction f = new FibAction(8);
485	>	assertSame(f, f.fork());
486	>	f.quietlyJoin();
487	>	assertEquals(21, f.result);
488	>	checkCompletedNormally(f);
489	>	}};
490	>	testInvokeOnPool(mainPool(), a);
491		}
492
217	–
218	–	/**
219	–	* quietlyHelpJoin of a forked task returns when task completes
220	–	*/
221	–	public void testForkQuietlyHelpJoin() {
222	–	RecursiveAction a = new RecursiveAction() {
223	–	public void compute() {
224	–	FibAction f = new FibAction(8);
225	–	f.fork();
226	–	f.quietlyHelpJoin();
227	–	threadAssertTrue(f.result == 21);
228	–	threadAssertTrue(f.isDone());
229	–	}
230	–	};
231	–	mainPool.invoke(a);
232	–	}
233	–
234	–
493		/**
494		* helpQuiesce returns when tasks are complete.
495		* getQueuedTaskCount returns 0 when quiescent
496		*/
497		public void testForkHelpQuiesce() {
498	<	RecursiveAction a = new RecursiveAction() {
499	<	public void compute() {
500	<	FibAction f = new FibAction(8);
501	<	f.fork();
502	<	f.helpQuiesce();
503	<	threadAssertTrue(f.result == 21);
504	<	threadAssertTrue(f.isDone());
505	<	threadAssertTrue(getQueuedTaskCount() == 0);
506	<	}
507	<	};
250	<	mainPool.invoke(a);
498	>	RecursiveAction a = new CheckedRecursiveAction() {
499	>	public void realCompute() {
500	>	FibAction f = new FibAction(8);
501	>	assertSame(f, f.fork());
502	>	helpQuiesce();
503	>	assertEquals(21, f.result);
504	>	assertEquals(0, getQueuedTaskCount());
505	>	checkCompletedNormally(f);
506	>	}};
507	>	testInvokeOnPool(mainPool(), a);
508		}
509
253	–
510		/**
511		* invoke task throws exception when task completes abnormally
512		*/
513		public void testAbnormalInvoke() {
514	<	RecursiveAction a = new RecursiveAction() {
515	<	public void compute() {
516	<	try {
517	<	FailingFibAction f = new FailingFibAction(8);
518	<	f.invoke();
519	<	shouldThrow();
520	<	} catch (FJException success) {
521	<	}
514	>	RecursiveAction a = new CheckedRecursiveAction() {
515	>	public void realCompute() {
516	>	FailingFibAction f = new FailingFibAction(8);
517	>	try {
518	>	f.invoke();
519	>	shouldThrow();
520	>	} catch (FJException success) {
521	>	checkCompletedAbnormally(f, success);
522		}
523	<	};
524	<	mainPool.invoke(a);
523	>	}};
524	>	testInvokeOnPool(mainPool(), a);
525		}
526
527		/**
528		* quietlyInvoke task returns when task completes abnormally
529		*/
530		public void testAbnormalQuietlyInvoke() {
531	<	RecursiveAction a = new RecursiveAction() {
532	<	public void compute() {
533	<	FailingFibAction f = new FailingFibAction(8);
534	<	f.quietlyInvoke();
535	<	threadAssertTrue(f.isDone());
536	<	}
537	<	};
538	<	mainPool.invoke(a);
531	>	RecursiveAction a = new CheckedRecursiveAction() {
532	>	public void realCompute() {
533	>	FailingFibAction f = new FailingFibAction(8);
534	>	f.quietlyInvoke();
535	>	assertTrue(f.getException() instanceof FJException);
536	>	checkCompletedAbnormally(f, f.getException());
537	>	}};
538	>	testInvokeOnPool(mainPool(), a);
539		}
540
541		/**
542		* join of a forked task throws exception when task completes abnormally
543		*/
544		public void testAbnormalForkJoin() {
545	<	RecursiveAction a = new RecursiveAction() {
546	<	public void compute() {
547	<	try {
548	<	FailingFibAction f = new FailingFibAction(8);
549	<	f.fork();
550	<	f.join();
551	<	shouldThrow();
552	<	} catch (FJException success) {
553	<	}
545	>	RecursiveAction a = new CheckedRecursiveAction() {
546	>	public void realCompute() {
547	>	FailingFibAction f = new FailingFibAction(8);
548	>	assertSame(f, f.fork());
549	>	try {
550	>	f.join();
551	>	shouldThrow();
552	>	} catch (FJException success) {
553	>	checkCompletedAbnormally(f, success);
554		}
555	<	};
556	<	mainPool.invoke(a);
555	>	}};
556	>	testInvokeOnPool(mainPool(), a);
557		}
558
559		/**
560		* get of a forked task throws exception when task completes abnormally
561		*/
562		public void testAbnormalForkGet() {
563	<	RecursiveAction a = new RecursiveAction() {
564	<	public void compute() {
565	<	try {
566	<	FailingFibAction f = new FailingFibAction(8);
567	<	f.fork();
568	<	f.get();
569	<	shouldThrow();
570	<	} catch (ExecutionException success) {
571	<	} catch (Exception ex) {
572	<	unexpectedException(ex);
573	<	}
563	>	RecursiveAction a = new CheckedRecursiveAction() {
564	>	public void realCompute() throws Exception {
565	>	FailingFibAction f = new FailingFibAction(8);
566	>	assertSame(f, f.fork());
567	>	try {
568	>	f.get();
569	>	shouldThrow();
570	>	} catch (ExecutionException success) {
571	>	Throwable cause = success.getCause();
572	>	assertTrue(cause instanceof FJException);
573	>	checkCompletedAbnormally(f, cause);
574		}
575	<	};
576	<	mainPool.invoke(a);
575	>	}};
576	>	testInvokeOnPool(mainPool(), a);
577		}
578
579		/**
580		* timed get of a forked task throws exception when task completes abnormally
581		*/
582		public void testAbnormalForkTimedGet() {
583	<	RecursiveAction a = new RecursiveAction() {
584	<	public void compute() {
585	<	try {
586	<	FailingFibAction f = new FailingFibAction(8);
587	<	f.fork();
588	<	f.get(5L, TimeUnit.SECONDS);
589	<	shouldThrow();
590	<	} catch (ExecutionException success) {
591	<	} catch (Exception ex) {
592	<	unexpectedException(ex);
593	<	}
583	>	RecursiveAction a = new CheckedRecursiveAction() {
584	>	public void realCompute() throws Exception {
585	>	FailingFibAction f = new FailingFibAction(8);
586	>	assertSame(f, f.fork());
587	>	try {
588	>	f.get(5L, TimeUnit.SECONDS);
589	>	shouldThrow();
590	>	} catch (ExecutionException success) {
591	>	Throwable cause = success.getCause();
592	>	assertTrue(cause instanceof FJException);
593	>	checkCompletedAbnormally(f, cause);
594		}
595	<	};
596	<	mainPool.invoke(a);
341	<	}
342	<
343	<	/**
344	<	* join of a forked task throws exception when task completes abnormally
345	<	*/
346	<	public void testAbnormalForkHelpJoin() {
347	<	RecursiveAction a = new RecursiveAction() {
348	<	public void compute() {
349	<	try {
350	<	FailingFibAction f = new FailingFibAction(8);
351	<	f.fork();
352	<	f.helpJoin();
353	<	shouldThrow();
354	<	} catch (FJException success) {
355	<	}
356	<	}
357	<	};
358	<	mainPool.invoke(a);
359	<	}
360	<
361	<	/**
362	<	* quietlyHelpJoin of a forked task returns when task completes abnormally.
363	<	* getException of failed task returns its exception.
364	<	* isCompletedAbnormally of a failed task returns true.
365	<	* isCancelled of a failed uncancelled task returns false
366	<	*/
367	<	public void testAbnormalForkQuietlyHelpJoin() {
368	<	RecursiveAction a = new RecursiveAction() {
369	<	public void compute() {
370	<	FailingFibAction f = new FailingFibAction(8);
371	<	f.fork();
372	<	f.quietlyHelpJoin();
373	<	threadAssertTrue(f.isDone());
374	<	threadAssertTrue(f.isCompletedAbnormally());
375	<	threadAssertFalse(f.isCancelled());
376	<	threadAssertTrue(f.getException() instanceof FJException);
377	<	}
378	<	};
379	<	mainPool.invoke(a);
595	>	}};
596	>	testInvokeOnPool(mainPool(), a);
597		}
598
599		/**
600		* quietlyJoin of a forked task returns when task completes abnormally
601		*/
602		public void testAbnormalForkQuietlyJoin() {
603	<	RecursiveAction a = new RecursiveAction() {
604	<	public void compute() {
605	<	FailingFibAction f = new FailingFibAction(8);
606	<	f.fork();
607	<	f.quietlyJoin();
608	<	threadAssertTrue(f.isDone());
609	<	threadAssertTrue(f.isCompletedAbnormally());
610	<	threadAssertTrue(f.getException() instanceof FJException);
611	<	}
395	<	};
396	<	mainPool.invoke(a);
603	>	RecursiveAction a = new CheckedRecursiveAction() {
604	>	public void realCompute() {
605	>	FailingFibAction f = new FailingFibAction(8);
606	>	assertSame(f, f.fork());
607	>	f.quietlyJoin();
608	>	assertTrue(f.getException() instanceof FJException);
609	>	checkCompletedAbnormally(f, f.getException());
610	>	}};
611	>	testInvokeOnPool(mainPool(), a);
612		}
613
614		/**
615		* invoke task throws exception when task cancelled
616		*/
617		public void testCancelledInvoke() {
618	<	RecursiveAction a = new RecursiveAction() {
619	<	public void compute() {
620	<	try {
621	<	FibAction f = new FibAction(8);
622	<	f.cancel(true);
623	<	f.invoke();
624	<	shouldThrow();
625	<	} catch (CancellationException success) {
626	<	}
618	>	RecursiveAction a = new CheckedRecursiveAction() {
619	>	public void realCompute() {
620	>	FibAction f = new FibAction(8);
621	>	assertTrue(f.cancel(true));
622	>	try {
623	>	f.invoke();
624	>	shouldThrow();
625	>	} catch (CancellationException success) {
626	>	checkCancelled(f);
627		}
628	<	};
629	<	mainPool.invoke(a);
628	>	}};
629	>	testInvokeOnPool(mainPool(), a);
630		}
631
632		/**
633		* join of a forked task throws exception when task cancelled
634		*/
635		public void testCancelledForkJoin() {
636	<	RecursiveAction a = new RecursiveAction() {
637	<	public void compute() {
638	<	try {
639	<	FibAction f = new FibAction(8);
640	<	f.cancel(true);
641	<	f.fork();
642	<	f.join();
643	<	shouldThrow();
644	<	} catch (CancellationException success) {
645	<	}
636	>	RecursiveAction a = new CheckedRecursiveAction() {
637	>	public void realCompute() {
638	>	FibAction f = new FibAction(8);
639	>	assertTrue(f.cancel(true));
640	>	assertSame(f, f.fork());
641	>	try {
642	>	f.join();
643	>	shouldThrow();
644	>	} catch (CancellationException success) {
645	>	checkCancelled(f);
646		}
647	<	};
648	<	mainPool.invoke(a);
647	>	}};
648	>	testInvokeOnPool(mainPool(), a);
649		}
650
651		/**
652		* get of a forked task throws exception when task cancelled
653		*/
654		public void testCancelledForkGet() {
655	<	RecursiveAction a = new RecursiveAction() {
656	<	public void compute() {
657	<	try {
658	<	FibAction f = new FibAction(8);
659	<	f.cancel(true);
660	<	f.fork();
661	<	f.get();
662	<	shouldThrow();
663	<	} catch (CancellationException success) {
664	<	} catch (Exception ex) {
450	<	unexpectedException(ex);
451	<	}
655	>	RecursiveAction a = new CheckedRecursiveAction() {
656	>	public void realCompute() throws Exception {
657	>	FibAction f = new FibAction(8);
658	>	assertTrue(f.cancel(true));
659	>	assertSame(f, f.fork());
660	>	try {
661	>	f.get();
662	>	shouldThrow();
663	>	} catch (CancellationException success) {
664	>	checkCancelled(f);
665		}
666	<	};
667	<	mainPool.invoke(a);
666	>	}};
667	>	testInvokeOnPool(mainPool(), a);
668		}
669
670		/**
671		* timed get of a forked task throws exception when task cancelled
672		*/
673		public void testCancelledForkTimedGet() {
674	<	RecursiveAction a = new RecursiveAction() {
675	<	public void compute() {
676	<	try {
677	<	FibAction f = new FibAction(8);
678	<	f.cancel(true);
679	<	f.fork();
680	<	f.get(5L, TimeUnit.SECONDS);
681	<	shouldThrow();
682	<	} catch (CancellationException success) {
683	<	} catch (Exception ex) {
471	<	unexpectedException(ex);
472	<	}
674	>	RecursiveAction a = new CheckedRecursiveAction() {
675	>	public void realCompute() throws Exception {
676	>	FibAction f = new FibAction(8);
677	>	assertTrue(f.cancel(true));
678	>	assertSame(f, f.fork());
679	>	try {
680	>	f.get(5L, SECONDS);
681	>	shouldThrow();
682	>	} catch (CancellationException success) {
683	>	checkCancelled(f);
684		}
685	<	};
686	<	mainPool.invoke(a);
476	<	}
477	<
478	<	/**
479	<	* join of a forked task throws exception when task cancelled
480	<	*/
481	<	public void testCancelledForkHelpJoin() {
482	<	RecursiveAction a = new RecursiveAction() {
483	<	public void compute() {
484	<	try {
485	<	FibAction f = new FibAction(8);
486	<	f.cancel(true);
487	<	f.fork();
488	<	f.helpJoin();
489	<	shouldThrow();
490	<	} catch (CancellationException success) {
491	<	}
492	<	}
493	<	};
494	<	mainPool.invoke(a);
495	<	}
496	<
497	<	/**
498	<	* quietlyHelpJoin of a forked task returns when task cancelled.
499	<	* getException of cancelled task returns its exception.
500	<	* isCompletedAbnormally of a cancelled task returns true.
501	<	* isCancelled of a cancelled task returns true
502	<	*/
503	<	public void testCancelledForkQuietlyHelpJoin() {
504	<	RecursiveAction a = new RecursiveAction() {
505	<	public void compute() {
506	<	FibAction f = new FibAction(8);
507	<	f.cancel(true);
508	<	f.fork();
509	<	f.quietlyHelpJoin();
510	<	threadAssertTrue(f.isDone());
511	<	threadAssertTrue(f.isCompletedAbnormally());
512	<	threadAssertTrue(f.isCancelled());
513	<	threadAssertTrue(f.getException() instanceof CancellationException);
514	<	}
515	<	};
516	<	mainPool.invoke(a);
685	>	}};
686	>	testInvokeOnPool(mainPool(), a);
687		}
688
689		/**
690		* quietlyJoin of a forked task returns when task cancelled
691		*/
692		public void testCancelledForkQuietlyJoin() {
693	<	RecursiveAction a = new RecursiveAction() {
694	<	public void compute() {
695	<	FibAction f = new FibAction(8);
696	<	f.cancel(true);
697	<	f.fork();
698	<	f.quietlyJoin();
699	<	threadAssertTrue(f.isDone());
700	<	threadAssertTrue(f.isCompletedAbnormally());
701	<	threadAssertTrue(f.getException() instanceof CancellationException);
532	<	}
533	<	};
534	<	mainPool.invoke(a);
693	>	RecursiveAction a = new CheckedRecursiveAction() {
694	>	public void realCompute() {
695	>	FibAction f = new FibAction(8);
696	>	assertTrue(f.cancel(true));
697	>	assertSame(f, f.fork());
698	>	f.quietlyJoin();
699	>	checkCancelled(f);
700	>	}};
701	>	testInvokeOnPool(mainPool(), a);
702		}
703
704		/**
705		* getPool of executing task returns its pool
706		*/
707		public void testGetPool() {
708	<	RecursiveAction a = new RecursiveAction() {
709	<	public void compute() {
710	<	threadAssertTrue(getPool() == mainPool);
711	<	}
712	<	};
713	<	mainPool.invoke(a);
708	>	final ForkJoinPool mainPool = mainPool();
709	>	RecursiveAction a = new CheckedRecursiveAction() {
710	>	public void realCompute() {
711	>	assertSame(mainPool, getPool());
712	>	}};
713	>	testInvokeOnPool(mainPool, a);
714		}
715
716		/**
717		* getPool of non-FJ task returns null
718		*/
719		public void testGetPool2() {
720	<	RecursiveAction a = new RecursiveAction() {
721	<	public void compute() {
722	<	threadAssertTrue(getPool() == null);
723	<	}
724	<	};
558	<	a.invoke();
720	>	RecursiveAction a = new CheckedRecursiveAction() {
721	>	public void realCompute() {
722	>	assertNull(getPool());
723	>	}};
724	>	assertNull(a.invoke());
725		}
726
727		/**
728		* inForkJoinPool of executing task returns true
729		*/
730		public void testInForkJoinPool() {
731	<	RecursiveAction a = new RecursiveAction() {
732	<	public void compute() {
733	<	threadAssertTrue(inForkJoinPool());
734	<	}
735	<	};
570	<	mainPool.invoke(a);
731	>	RecursiveAction a = new CheckedRecursiveAction() {
732	>	public void realCompute() {
733	>	assertTrue(inForkJoinPool());
734	>	}};
735	>	testInvokeOnPool(mainPool(), a);
736		}
737
738		/**
739		* inForkJoinPool of non-FJ task returns false
740		*/
741		public void testInForkJoinPool2() {
742	<	RecursiveAction a = new RecursiveAction() {
743	<	public void compute() {
744	<	threadAssertTrue(!inForkJoinPool());
745	<	}
746	<	};
582	<	a.invoke();
742	>	RecursiveAction a = new CheckedRecursiveAction() {
743	>	public void realCompute() {
744	>	assertFalse(inForkJoinPool());
745	>	}};
746	>	assertNull(a.invoke());
747		}
748
749		/**
750		* getPool of current thread in pool returns its pool
751		*/
752		public void testWorkerGetPool() {
753	<	RecursiveAction a = new RecursiveAction() {
754	<	public void compute() {
755	<	ForkJoinWorkerThread w =
756	<	(ForkJoinWorkerThread)(Thread.currentThread());
757	<	threadAssertTrue(w.getPool() == mainPool);
758	<	}
759	<	};
760	<	mainPool.invoke(a);
753	>	final ForkJoinPool mainPool = mainPool();
754	>	RecursiveAction a = new CheckedRecursiveAction() {
755	>	public void realCompute() {
756	>	ForkJoinWorkerThread w =
757	>	(ForkJoinWorkerThread) Thread.currentThread();
758	>	assertSame(mainPool, w.getPool());
759	>	}};
760	>	testInvokeOnPool(mainPool, a);
761		}
762
763		/**
764		* getPoolIndex of current thread in pool returns 0 <= value < poolSize
601	–	*
765		*/
766		public void testWorkerGetPoolIndex() {
767	<	RecursiveAction a = new RecursiveAction() {
768	<	public void compute() {
769	<	ForkJoinWorkerThread w =
770	<	(ForkJoinWorkerThread)(Thread.currentThread());
771	<	int idx = w.getPoolIndex();
772	<	threadAssertTrue(idx >= 0);
773	<	threadAssertTrue(idx < mainPool.getPoolSize());
774	<	}
775	<	};
776	<	mainPool.invoke(a);
767	>	final ForkJoinPool mainPool = mainPool();
768	>	RecursiveAction a = new CheckedRecursiveAction() {
769	>	public void realCompute() {
770	>	ForkJoinWorkerThread w =
771	>	(ForkJoinWorkerThread) Thread.currentThread();
772	>	assertTrue(w.getPoolIndex() >= 0);
773	>	// pool size can shrink after assigning index, so cannot check
774	>	// assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
775	>	}};
776	>	testInvokeOnPool(mainPool, a);
777		}
778
616	–
779		/**
780		* setRawResult(null) succeeds
781		*/
782		public void testSetRawResult() {
783	<	RecursiveAction a = new RecursiveAction() {
784	<	public void compute() {
785	<	setRawResult(null);
786	<	}
787	<	};
788	<	a.invoke();
783	>	RecursiveAction a = new CheckedRecursiveAction() {
784	>	public void realCompute() {
785	>	setRawResult(null);
786	>	assertNull(getRawResult());
787	>	}};
788	>	assertNull(a.invoke());
789		}
790
791		/**
792		* A reinitialized task may be re-invoked
793		*/
794		public void testReinitialize() {
795	<	RecursiveAction a = new RecursiveAction() {
796	<	public void compute() {
797	<	FibAction f = new FibAction(8);
798	<	f.invoke();
799	<	threadAssertTrue(f.result == 21);
800	<	threadAssertTrue(f.isDone());
801	<	threadAssertFalse(f.isCancelled());
802	<	threadAssertFalse(f.isCompletedAbnormally());
795	>	RecursiveAction a = new CheckedRecursiveAction() {
796	>	public void realCompute() {
797	>	FibAction f = new FibAction(8);
798	>	checkNotDone(f);
799	>
800	>	for (int i = 0; i < 3; i++) {
801	>	assertNull(f.invoke());
802	>	assertEquals(21, f.result);
803	>	checkCompletedNormally(f);
804		f.reinitialize();
805	<	f.invoke();
643	<	threadAssertTrue(f.result == 21);
805	>	checkNotDone(f);
806		}
807	<	};
808	<	mainPool.invoke(a);
807	>	}};
808	>	testInvokeOnPool(mainPool(), a);
809		}
810
811		/**
812		* invoke task throws exception after invoking completeExceptionally
813		*/
814		public void testCompleteExceptionally() {
815	<	RecursiveAction a = new RecursiveAction() {
816	<	public void compute() {
817	<	try {
818	<	FibAction f = new FibAction(8);
819	<	f.completeExceptionally(new FJException());
820	<	f.invoke();
821	<	shouldThrow();
822	<	} catch (FJException success) {
823	<	}
815	>	RecursiveAction a = new CheckedRecursiveAction() {
816	>	public void realCompute() {
817	>	FibAction f = new FibAction(8);
818	>	f.completeExceptionally(new FJException());
819	>	try {
820	>	f.invoke();
821	>	shouldThrow();
822	>	} catch (FJException success) {
823	>	checkCompletedAbnormally(f, success);
824		}
825	<	};
826	<	mainPool.invoke(a);
825	>	}};
826	>	testInvokeOnPool(mainPool(), a);
827		}
828
829		/**
830		* invoke task suppresses execution invoking complete
831		*/
832		public void testComplete() {
833	<	RecursiveAction a = new RecursiveAction() {
834	<	public void compute() {
835	<	FibAction f = new FibAction(8);
836	<	f.complete(null);
837	<	f.invoke();
838	<	threadAssertTrue(f.isDone());
839	<	threadAssertTrue(f.result == 0);
840	<	}
841	<	};
680	<	mainPool.invoke(a);
833	>	RecursiveAction a = new CheckedRecursiveAction() {
834	>	public void realCompute() {
835	>	FibAction f = new FibAction(8);
836	>	f.complete(null);
837	>	assertNull(f.invoke());
838	>	assertEquals(0, f.result);
839	>	checkCompletedNormally(f);
840	>	}};
841	>	testInvokeOnPool(mainPool(), a);
842		}
843
844		/**
845		* invokeAll(t1, t2) invokes all task arguments
846		*/
847		public void testInvokeAll2() {
848	<	RecursiveAction a = new RecursiveAction() {
849	<	public void compute() {
850	<	FibAction f = new FibAction(8);
851	<	FibAction g = new FibAction(9);
852	<	invokeAll(f, g);
853	<	threadAssertTrue(f.isDone());
854	<	threadAssertTrue(f.result == 21);
855	<	threadAssertTrue(g.isDone());
856	<	threadAssertTrue(g.result == 34);
857	<	}
858	<	};
698	<	mainPool.invoke(a);
848	>	RecursiveAction a = new CheckedRecursiveAction() {
849	>	public void realCompute() {
850	>	FibAction f = new FibAction(8);
851	>	FibAction g = new FibAction(9);
852	>	invokeAll(f, g);
853	>	checkCompletedNormally(f);
854	>	assertEquals(21, f.result);
855	>	checkCompletedNormally(g);
856	>	assertEquals(34, g.result);
857	>	}};
858	>	testInvokeOnPool(mainPool(), a);
859		}
860
861		/**
862		* invokeAll(tasks) with 1 argument invokes task
863		*/
864		public void testInvokeAll1() {
865	<	RecursiveAction a = new RecursiveAction() {
866	<	public void compute() {
867	<	FibAction f = new FibAction(8);
868	<	invokeAll(f);
869	<	threadAssertTrue(f.isDone());
870	<	threadAssertTrue(f.result == 21);
871	<	}
872	<	};
713	<	mainPool.invoke(a);
865	>	RecursiveAction a = new CheckedRecursiveAction() {
866	>	public void realCompute() {
867	>	FibAction f = new FibAction(8);
868	>	invokeAll(f);
869	>	checkCompletedNormally(f);
870	>	assertEquals(21, f.result);
871	>	}};
872	>	testInvokeOnPool(mainPool(), a);
873		}
874
875		/**
876		* invokeAll(tasks) with > 2 argument invokes tasks
877		*/
878		public void testInvokeAll3() {
879	<	RecursiveAction a = new RecursiveAction() {
880	<	public void compute() {
881	<	FibAction f = new FibAction(8);
882	<	FibAction g = new FibAction(9);
883	<	FibAction h = new FibAction(7);
884	<	invokeAll(f, g, h);
885	<	threadAssertTrue(f.isDone());
886	<	threadAssertTrue(f.result == 21);
887	<	threadAssertTrue(g.isDone());
888	<	threadAssertTrue(g.result == 34);
889	<	threadAssertTrue(h.isDone());
890	<	threadAssertTrue(h.result == 13);
891	<	}
892	<	};
893	<	mainPool.invoke(a);
879	>	RecursiveAction a = new CheckedRecursiveAction() {
880	>	public void realCompute() {
881	>	FibAction f = new FibAction(8);
882	>	FibAction g = new FibAction(9);
883	>	FibAction h = new FibAction(7);
884	>	invokeAll(f, g, h);
885	>	assertTrue(f.isDone());
886	>	assertTrue(g.isDone());
887	>	assertTrue(h.isDone());
888	>	checkCompletedNormally(f);
889	>	assertEquals(21, f.result);
890	>	checkCompletedNormally(g);
891	>	assertEquals(34, g.result);
892	>	checkCompletedNormally(g);
893	>	assertEquals(13, h.result);
894	>	}};
895	>	testInvokeOnPool(mainPool(), a);
896		}
897
898		/**
899		* invokeAll(collection) invokes all tasks in the collection
900		*/
901		public void testInvokeAllCollection() {
902	<	RecursiveAction a = new RecursiveAction() {
903	<	public void compute() {
904	<	FibAction f = new FibAction(8);
905	<	FibAction g = new FibAction(9);
906	<	FibAction h = new FibAction(7);
907	<	HashSet set = new HashSet();
908	<	set.add(f);
909	<	set.add(g);
910	<	set.add(h);
911	<	invokeAll(set);
912	<	threadAssertTrue(f.isDone());
913	<	threadAssertTrue(f.result == 21);
914	<	threadAssertTrue(g.isDone());
915	<	threadAssertTrue(g.result == 34);
916	<	threadAssertTrue(h.isDone());
917	<	threadAssertTrue(h.result == 13);
918	<	}
919	<	};
920	<	mainPool.invoke(a);
902	>	RecursiveAction a = new CheckedRecursiveAction() {
903	>	public void realCompute() {
904	>	FibAction f = new FibAction(8);
905	>	FibAction g = new FibAction(9);
906	>	FibAction h = new FibAction(7);
907	>	HashSet set = new HashSet();
908	>	set.add(f);
909	>	set.add(g);
910	>	set.add(h);
911	>	invokeAll(set);
912	>	assertTrue(f.isDone());
913	>	assertTrue(g.isDone());
914	>	assertTrue(h.isDone());
915	>	checkCompletedNormally(f);
916	>	assertEquals(21, f.result);
917	>	checkCompletedNormally(g);
918	>	assertEquals(34, g.result);
919	>	checkCompletedNormally(g);
920	>	assertEquals(13, h.result);
921	>	}};
922	>	testInvokeOnPool(mainPool(), a);
923		}
924
762	–
925		/**
926		* invokeAll(tasks) with any null task throws NPE
927		*/
928		public void testInvokeAllNPE() {
929	<	RecursiveAction a = new RecursiveAction() {
930	<	public void compute() {
931	<	try {
932	<	FibAction f = new FibAction(8);
933	<	FibAction g = new FibAction(9);
934	<	FibAction h = null;
935	<	invokeAll(f, g, h);
936	<	shouldThrow();
937	<	} catch (NullPointerException success) {
938	<	}
939	<	}
778	<	};
779	<	mainPool.invoke(a);
929	>	RecursiveAction a = new CheckedRecursiveAction() {
930	>	public void realCompute() {
931	>	FibAction f = new FibAction(8);
932	>	FibAction g = new FibAction(9);
933	>	FibAction h = null;
934	>	try {
935	>	invokeAll(f, g, h);
936	>	shouldThrow();
937	>	} catch (NullPointerException success) {}
938	>	}};
939	>	testInvokeOnPool(mainPool(), a);
940		}
941
942		/**
943		* invokeAll(t1, t2) throw exception if any task does
944		*/
945		public void testAbnormalInvokeAll2() {
946	<	RecursiveAction a = new RecursiveAction() {
947	<	public void compute() {
948	<	try {
949	<	FibAction f = new FibAction(8);
950	<	FailingFibAction g = new FailingFibAction(9);
951	<	invokeAll(f, g);
952	<	shouldThrow();
953	<	} catch (FJException success) {
954	<	}
946	>	RecursiveAction a = new CheckedRecursiveAction() {
947	>	public void realCompute() {
948	>	FibAction f = new FibAction(8);
949	>	FailingFibAction g = new FailingFibAction(9);
950	>	try {
951	>	invokeAll(f, g);
952	>	shouldThrow();
953	>	} catch (FJException success) {
954	>	checkCompletedAbnormally(g, success);
955		}
956	<	};
957	<	mainPool.invoke(a);
956	>	}};
957	>	testInvokeOnPool(mainPool(), a);
958		}
959
960		/**
961		* invokeAll(tasks) with 1 argument throws exception if task does
962		*/
963		public void testAbnormalInvokeAll1() {
964	<	RecursiveAction a = new RecursiveAction() {
965	<	public void compute() {
966	<	try {
967	<	FailingFibAction g = new FailingFibAction(9);
968	<	invokeAll(g);
969	<	shouldThrow();
970	<	} catch (FJException success) {
971	<	}
964	>	RecursiveAction a = new CheckedRecursiveAction() {
965	>	public void realCompute() {
966	>	FailingFibAction g = new FailingFibAction(9);
967	>	try {
968	>	invokeAll(g);
969	>	shouldThrow();
970	>	} catch (FJException success) {
971	>	checkCompletedAbnormally(g, success);
972		}
973	<	};
974	<	mainPool.invoke(a);
973	>	}};
974	>	testInvokeOnPool(mainPool(), a);
975		}
976
977		/**
978		* invokeAll(tasks) with > 2 argument throws exception if any task does
979		*/
980		public void testAbnormalInvokeAll3() {
981	<	RecursiveAction a = new RecursiveAction() {
982	<	public void compute() {
983	<	try {
984	<	FibAction f = new FibAction(8);
985	<	FailingFibAction g = new FailingFibAction(9);
986	<	FibAction h = new FibAction(7);
987	<	invokeAll(f, g, h);
988	<	shouldThrow();
989	<	} catch (FJException success) {
990	<	}
981	>	RecursiveAction a = new CheckedRecursiveAction() {
982	>	public void realCompute() {
983	>	FibAction f = new FibAction(8);
984	>	FailingFibAction g = new FailingFibAction(9);
985	>	FibAction h = new FibAction(7);
986	>	try {
987	>	invokeAll(f, g, h);
988	>	shouldThrow();
989	>	} catch (FJException success) {
990	>	checkCompletedAbnormally(g, success);
991		}
992	<	};
993	<	mainPool.invoke(a);
992	>	}};
993	>	testInvokeOnPool(mainPool(), a);
994		}
995
996		/**
997		* invokeAll(collection) throws exception if any task does
998		*/
999		public void testAbnormalInvokeAllCollection() {
1000	<	RecursiveAction a = new RecursiveAction() {
1001	<	public void compute() {
1002	<	try {
1003	<	FailingFibAction f = new FailingFibAction(8);
1004	<	FibAction g = new FibAction(9);
1005	<	FibAction h = new FibAction(7);
1006	<	HashSet set = new HashSet();
1007	<	set.add(f);
1008	<	set.add(g);
1009	<	set.add(h);
1010	<	invokeAll(set);
1011	<	shouldThrow();
1012	<	} catch (FJException success) {
1013	<	}
1000	>	RecursiveAction a = new CheckedRecursiveAction() {
1001	>	public void realCompute() {
1002	>	FailingFibAction f = new FailingFibAction(8);
1003	>	FibAction g = new FibAction(9);
1004	>	FibAction h = new FibAction(7);
1005	>	HashSet set = new HashSet();
1006	>	set.add(f);
1007	>	set.add(g);
1008	>	set.add(h);
1009	>	try {
1010	>	invokeAll(set);
1011	>	shouldThrow();
1012	>	} catch (FJException success) {
1013	>	checkCompletedAbnormally(f, success);
1014		}
1015	<	};
1016	<	mainPool.invoke(a);
1015	>	}};
1016	>	testInvokeOnPool(mainPool(), a);
1017		}
1018
1019		/**
#	Line 861 | Line 1021 | public class RecursiveActionTest extends
1021		* and suppresses execution
1022		*/
1023		public void testTryUnfork() {
1024	<	RecursiveAction a = new RecursiveAction() {
1025	<	public void compute() {
1026	<	FibAction g = new FibAction(9);
1027	<	g.fork();
1028	<	FibAction f = new FibAction(8);
1029	<	f.fork();
1030	<	threadAssertTrue(f.tryUnfork());
1031	<	helpQuiesce();
1032	<	threadAssertFalse(f.isDone());
1033	<	threadAssertTrue(g.isDone());
1034	<	}
1035	<	};
876	<	singletonPool.invoke(a);
1024	>	RecursiveAction a = new CheckedRecursiveAction() {
1025	>	public void realCompute() {
1026	>	FibAction g = new FibAction(9);
1027	>	assertSame(g, g.fork());
1028	>	FibAction f = new FibAction(8);
1029	>	assertSame(f, f.fork());
1030	>	assertTrue(f.tryUnfork());
1031	>	helpQuiesce();
1032	>	checkNotDone(f);
1033	>	checkCompletedNormally(g);
1034	>	}};
1035	>	testInvokeOnPool(singletonPool(), a);
1036		}
1037
1038		/**
#	Line 881 | Line 1040 | public class RecursiveActionTest extends
1040		* there are more tasks than threads
1041		*/
1042		public void testGetSurplusQueuedTaskCount() {
1043	<	RecursiveAction a = new RecursiveAction() {
1044	<	public void compute() {
1045	<	FibAction h = new FibAction(7);
1046	<	h.fork();
1047	<	FibAction g = new FibAction(9);
1048	<	g.fork();
1049	<	FibAction f = new FibAction(8);
1050	<	f.fork();
1051	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
1052	<	helpQuiesce();
1053	<	}
1054	<	};
1055	<	singletonPool.invoke(a);
1043	>	RecursiveAction a = new CheckedRecursiveAction() {
1044	>	public void realCompute() {
1045	>	FibAction h = new FibAction(7);
1046	>	assertSame(h, h.fork());
1047	>	FibAction g = new FibAction(9);
1048	>	assertSame(g, g.fork());
1049	>	FibAction f = new FibAction(8);
1050	>	assertSame(f, f.fork());
1051	>	assertTrue(getSurplusQueuedTaskCount() > 0);
1052	>	helpQuiesce();
1053	>	assertEquals(0, getSurplusQueuedTaskCount());
1054	>	checkCompletedNormally(f);
1055	>	checkCompletedNormally(g);
1056	>	checkCompletedNormally(h);
1057	>	}};
1058	>	testInvokeOnPool(singletonPool(), a);
1059		}
1060
1061		/**
1062		* peekNextLocalTask returns most recent unexecuted task.
1063		*/
1064		public void testPeekNextLocalTask() {
1065	<	RecursiveAction a = new RecursiveAction() {
1066	<	public void compute() {
1067	<	FibAction g = new FibAction(9);
1068	<	g.fork();
1069	<	FibAction f = new FibAction(8);
1070	<	f.fork();
1071	<	threadAssertTrue(peekNextLocalTask() == f);
1072	<	f.join();
1073	<	threadAssertTrue(f.isDone());
1074	<	helpQuiesce();
1075	<	}
1076	<	};
1077	<	singletonPool.invoke(a);
1065	>	RecursiveAction a = new CheckedRecursiveAction() {
1066	>	public void realCompute() {
1067	>	FibAction g = new FibAction(9);
1068	>	assertSame(g, g.fork());
1069	>	FibAction f = new FibAction(8);
1070	>	assertSame(f, f.fork());
1071	>	assertSame(f, peekNextLocalTask());
1072	>	assertNull(f.join());
1073	>	checkCompletedNormally(f);
1074	>	helpQuiesce();
1075	>	checkCompletedNormally(f);
1076	>	checkCompletedNormally(g);
1077	>	}};
1078	>	testInvokeOnPool(singletonPool(), a);
1079		}
1080
1081		/**
#	Line 920 | Line 1083 | public class RecursiveActionTest extends
1083		* without executing it
1084		*/
1085		public void testPollNextLocalTask() {
1086	<	RecursiveAction a = new RecursiveAction() {
1087	<	public void compute() {
1088	<	FibAction g = new FibAction(9);
1089	<	g.fork();
1090	<	FibAction f = new FibAction(8);
1091	<	f.fork();
1092	<	threadAssertTrue(pollNextLocalTask() == f);
1093	<	helpQuiesce();
1094	<	threadAssertFalse(f.isDone());
1095	<	}
1096	<	};
1097	<	singletonPool.invoke(a);
1086	>	RecursiveAction a = new CheckedRecursiveAction() {
1087	>	public void realCompute() {
1088	>	FibAction g = new FibAction(9);
1089	>	assertSame(g, g.fork());
1090	>	FibAction f = new FibAction(8);
1091	>	assertSame(f, f.fork());
1092	>	assertSame(f, pollNextLocalTask());
1093	>	helpQuiesce();
1094	>	checkNotDone(f);
1095	>	checkCompletedNormally(g);
1096	>	}};
1097	>	testInvokeOnPool(singletonPool(), a);
1098		}
1099
1100		/**
1101	<	* pollTask returns an unexecuted task
939	<	* without executing it
1101	>	* pollTask returns an unexecuted task without executing it
1102		*/
1103		public void testPollTask() {
1104	<	RecursiveAction a = new RecursiveAction() {
1105	<	public void compute() {
1106	<	FibAction g = new FibAction(9);
1107	<	g.fork();
1108	<	FibAction f = new FibAction(8);
1109	<	f.fork();
1110	<	threadAssertTrue(pollTask() == f);
1111	<	helpQuiesce();
1112	<	threadAssertFalse(f.isDone());
1113	<	threadAssertTrue(g.isDone());
1114	<	}
1115	<	};
954	<	singletonPool.invoke(a);
1104	>	RecursiveAction a = new CheckedRecursiveAction() {
1105	>	public void realCompute() {
1106	>	FibAction g = new FibAction(9);
1107	>	assertSame(g, g.fork());
1108	>	FibAction f = new FibAction(8);
1109	>	assertSame(f, f.fork());
1110	>	assertSame(f, pollTask());
1111	>	helpQuiesce();
1112	>	checkNotDone(f);
1113	>	checkCompletedNormally(g);
1114	>	}};
1115	>	testInvokeOnPool(singletonPool(), a);
1116		}
1117
1118		/**
1119		* peekNextLocalTask returns least recent unexecuted task in async mode
1120		*/
1121		public void testPeekNextLocalTaskAsync() {
1122	<	RecursiveAction a = new RecursiveAction() {
1123	<	public void compute() {
1124	<	FibAction g = new FibAction(9);
1125	<	g.fork();
1126	<	FibAction f = new FibAction(8);
1127	<	f.fork();
1128	<	threadAssertTrue(peekNextLocalTask() == g);
1129	<	f.join();
1130	<	helpQuiesce();
1131	<	threadAssertTrue(f.isDone());
1132	<	}
1133	<	};
1134	<	asyncSingletonPool.invoke(a);
1122	>	RecursiveAction a = new CheckedRecursiveAction() {
1123	>	public void realCompute() {
1124	>	FibAction g = new FibAction(9);
1125	>	assertSame(g, g.fork());
1126	>	FibAction f = new FibAction(8);
1127	>	assertSame(f, f.fork());
1128	>	assertSame(g, peekNextLocalTask());
1129	>	assertNull(f.join());
1130	>	helpQuiesce();
1131	>	checkCompletedNormally(f);
1132	>	checkCompletedNormally(g);
1133	>	}};
1134	>	testInvokeOnPool(asyncSingletonPool(), a);
1135		}
1136
1137		/**
1138	<	* pollNextLocalTask returns least recent unexecuted task
1139	<	* without executing it, in async mode
1138	>	* pollNextLocalTask returns least recent unexecuted task without
1139	>	* executing it, in async mode
1140		*/
1141		public void testPollNextLocalTaskAsync() {
1142	<	RecursiveAction a = new RecursiveAction() {
1143	<	public void compute() {
1144	<	FibAction g = new FibAction(9);
1145	<	g.fork();
1146	<	FibAction f = new FibAction(8);
1147	<	f.fork();
1148	<	threadAssertTrue(pollNextLocalTask() == g);
1149	<	helpQuiesce();
1150	<	threadAssertTrue(f.isDone());
1151	<	threadAssertFalse(g.isDone());
1152	<	}
1153	<	};
993	<	asyncSingletonPool.invoke(a);
1142	>	RecursiveAction a = new CheckedRecursiveAction() {
1143	>	public void realCompute() {
1144	>	FibAction g = new FibAction(9);
1145	>	assertSame(g, g.fork());
1146	>	FibAction f = new FibAction(8);
1147	>	assertSame(f, f.fork());
1148	>	assertSame(g, pollNextLocalTask());
1149	>	helpQuiesce();
1150	>	checkCompletedNormally(f);
1151	>	checkNotDone(g);
1152	>	}};
1153	>	testInvokeOnPool(asyncSingletonPool(), a);
1154		}
1155
1156		/**
1157	<	* pollTask returns an unexecuted task
1158	<	* without executing it, in async mode
1157	>	* pollTask returns an unexecuted task without executing it, in
1158	>	* async mode
1159		*/
1160		public void testPollTaskAsync() {
1161	<	RecursiveAction a = new RecursiveAction() {
1162	<	public void compute() {
1163	<	FibAction g = new FibAction(9);
1164	<	g.fork();
1165	<	FibAction f = new FibAction(8);
1166	<	f.fork();
1167	<	threadAssertTrue(pollTask() == g);
1168	<	helpQuiesce();
1169	<	threadAssertTrue(f.isDone());
1170	<	threadAssertFalse(g.isDone());
1171	<	}
1172	<	};
1013	<	asyncSingletonPool.invoke(a);
1161	>	RecursiveAction a = new CheckedRecursiveAction() {
1162	>	public void realCompute() {
1163	>	FibAction g = new FibAction(9);
1164	>	assertSame(g, g.fork());
1165	>	FibAction f = new FibAction(8);
1166	>	assertSame(f, f.fork());
1167	>	assertSame(g, pollTask());
1168	>	helpQuiesce();
1169	>	checkCompletedNormally(f);
1170	>	checkNotDone(g);
1171	>	}};
1172	>	testInvokeOnPool(asyncSingletonPool(), a);
1173		}
1174
1175		}

Diff Legend

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