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

Diff Legend

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