ViewVC Help

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

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

Comparing jsr166/src/test/tck/RecursiveTaskTest.java (file contents):
Revision 1.11 by jsr166, Wed Sep 1 06:41:55 2010 UTC vs.
Revision 1.19 by jsr166, Thu Sep 16 00:52:49 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.RecursiveTask;
12	+	import java.util.concurrent.TimeUnit;
13	+	import java.util.HashSet;
14
15		public class RecursiveTaskTest extends JSR166TestCase {
16
#	Line 17 | Line 21 | public class RecursiveTaskTest extends J
21		return new TestSuite(RecursiveTaskTest.class);
22		}
23
24	<	static final ForkJoinPool mainPool = new ForkJoinPool();
25	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
26	<	static final ForkJoinPool asyncSingletonPool =
27	<	new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory,
28	<	null, true);
24	>	private static ForkJoinPool mainPool() {
25	>	return new ForkJoinPool();
26	>	}
27	>
28	>	private static ForkJoinPool singletonPool() {
29	>	return new ForkJoinPool(1);
30	>	}
31	>
32	>	private static ForkJoinPool asyncSingletonPool() {
33	>	return new ForkJoinPool(1,
34	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
35	>	null, true);
36	>	}
37	>
38	>	private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
39	>	try {
40	>	assertFalse(a.isDone());
41	>	assertFalse(a.isCompletedNormally());
42	>	assertFalse(a.isCompletedAbnormally());
43	>	assertFalse(a.isCancelled());
44	>
45	>	T result = pool.invoke(a);
46	>
47	>	assertTrue(a.isDone());
48	>	assertTrue(a.isCompletedNormally());
49	>	assertFalse(a.isCompletedAbnormally());
50	>	assertFalse(a.isCancelled());
51	>	assertNull(a.getException());
52	>	return result;
53	>	} finally {
54	>	joinPool(pool);
55	>	}
56	>	}
57
58		static final class FJException extends RuntimeException {
59		FJException() { super(); }
#	Line 31 | Line 63 | public class RecursiveTaskTest extends J
63		static final Integer NoResult = Integer.valueOf(-17);
64
65		// A simple recursive task for testing
66	<	static final class FibTask extends RecursiveTask<Integer> {
66	>	final class FibTask extends CheckedRecursiveTask<Integer> {
67		final int number;
68		FibTask(int n) { number = n; }
69	<	public Integer compute() {
69	>	public Integer realCompute() {
70		int n = number;
71		if (n <= 1)
72		return n;
#	Line 45 | Line 77 | public class RecursiveTaskTest extends J
77		}
78
79		// A recursive action failing in base case
80	<	static final class FailingFibTask extends RecursiveTask<Integer> {
80	>	final class FailingFibTask extends RecursiveTask<Integer> {
81		final int number;
82		int result;
83		FailingFibTask(int n) { number = n; }
#	Line 64 | Line 96 | public class RecursiveTaskTest extends J
96		* isCompletedAbnormally and isCancelled return false for normally
97		* completed tasks. getRawResult of a completed non-null task
98		* returns value;
67	–	*
99		*/
100		public void testInvoke() {
101	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
102	<	public Integer compute() {
101	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
102	>	public Integer realCompute() {
103		FibTask f = new FibTask(8);
104		Integer r = f.invoke();
105	<	threadAssertTrue(r == 21);
106	<	threadAssertTrue(f.isDone());
107	<	threadAssertFalse(f.isCancelled());
108	<	threadAssertFalse(f.isCompletedAbnormally());
109	<	threadAssertTrue(f.getRawResult() == 21);
105	>	assertEquals(21, (int) r);
106	>	assertTrue(f.isDone());
107	>	assertFalse(f.isCancelled());
108	>	assertFalse(f.isCompletedAbnormally());
109	>	assertEquals(21, (int) f.getRawResult());
110		return r;
111	<	}
112	<	};
82	<	assertTrue(mainPool.invoke(a) == 21);
111	>	}};
112	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
113		}
114
115		/**
#	Line 88 | Line 118 | public class RecursiveTaskTest extends J
118		* completed tasks
119		*/
120		public void testQuietlyInvoke() {
121	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
122	<	public Integer compute() {
121	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
122	>	public Integer realCompute() {
123		FibTask f = new FibTask(8);
124		f.quietlyInvoke();
125		Integer r = f.getRawResult();
126	<	threadAssertTrue(r == 21);
127	<	threadAssertTrue(f.isDone());
128	<	threadAssertFalse(f.isCancelled());
129	<	threadAssertFalse(f.isCompletedAbnormally());
126	>	assertEquals(21, (int) r);
127	>	assertTrue(f.isDone());
128	>	assertFalse(f.isCancelled());
129	>	assertFalse(f.isCompletedAbnormally());
130		return r;
131	<	}
132	<	};
103	<	assertTrue(mainPool.invoke(a) == 21);
131	>	}};
132	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
133		}
134
135		/**
136		* join of a forked task returns when task completes
137		*/
138		public void testForkJoin() {
139	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
140	<	public Integer compute() {
139	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
140	>	public Integer realCompute() {
141		FibTask f = new FibTask(8);
142	<	f.fork();
142	>	assertSame(f, f.fork());
143		Integer r = f.join();
144	<	threadAssertTrue(r == 21);
145	<	threadAssertTrue(f.isDone());
144	>	assertEquals(21, (int) r);
145	>	assertTrue(f.isDone());
146		return r;
147	<	}
148	<	};
120	<	assertTrue(mainPool.invoke(a) == 21);
147	>	}};
148	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
149		}
150
151		/**
152		* get of a forked task returns when task completes
153		*/
154		public void testForkGet() {
155	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
156	<	public Integer compute() {
157	<	try {
158	<	FibTask f = new FibTask(8);
159	<	f.fork();
160	<	Integer r = f.get();
161	<	threadAssertTrue(r == 21);
162	<	threadAssertTrue(f.isDone());
163	<	return r;
164	<	} catch (Exception ex) {
137	<	unexpectedException(ex);
138	<	}
139	<	return NoResult;
140	<	}
141	<	};
142	<	assertTrue(mainPool.invoke(a) == 21);
155	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
156	>	public Integer realCompute() throws Exception {
157	>	FibTask f = new FibTask(8);
158	>	assertSame(f, f.fork());
159	>	Integer r = f.get();
160	>	assertEquals(21, (int) r);
161	>	assertTrue(f.isDone());
162	>	return r;
163	>	}};
164	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
165		}
166
167		/**
168		* timed get of a forked task returns when task completes
169		*/
170		public void testForkTimedGet() {
171	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
172	<	public Integer compute() {
173	<	try {
174	<	FibTask f = new FibTask(8);
175	<	f.fork();
176	<	Integer r = f.get(5L, TimeUnit.SECONDS);
177	<	threadAssertTrue(r == 21);
178	<	threadAssertTrue(f.isDone());
179	<	return r;
180	<	} catch (Exception ex) {
159	<	unexpectedException(ex);
160	<	}
161	<	return NoResult;
162	<	}
163	<	};
164	<	assertTrue(mainPool.invoke(a) == 21);
171	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
172	>	public Integer realCompute() throws Exception {
173	>	FibTask f = new FibTask(8);
174	>	assertSame(f, f.fork());
175	>	Integer r = f.get(5L, TimeUnit.SECONDS);
176	>	assertEquals(21, (int) r);
177	>	assertTrue(f.isDone());
178	>	return r;
179	>	}};
180	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
181		}
182
183		/**
184		* quietlyJoin of a forked task returns when task completes
185		*/
186		public void testForkQuietlyJoin() {
187	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
188	<	public Integer compute() {
187	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
188	>	public Integer realCompute() {
189		FibTask f = new FibTask(8);
190	<	f.fork();
190	>	assertSame(f, f.fork());
191		f.quietlyJoin();
192		Integer r = f.getRawResult();
193	<	threadAssertTrue(r == 21);
194	<	threadAssertTrue(f.isDone());
193	>	assertEquals(21, (int) r);
194	>	assertTrue(f.isDone());
195		return r;
196	<	}
197	<	};
182	<	assertTrue(mainPool.invoke(a) == 21);
196	>	}};
197	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
198		}
199
200
#	Line 188 | Line 203 | public class RecursiveTaskTest extends J
203		* getQueuedTaskCount returns 0 when quiescent
204		*/
205		public void testForkHelpQuiesce() {
206	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
207	<	public Integer compute() {
206	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
207	>	public Integer realCompute() {
208		FibTask f = new FibTask(8);
209	<	f.fork();
209	>	assertSame(f, f.fork());
210		f.helpQuiesce();
211		Integer r = f.getRawResult();
212	<	threadAssertTrue(r == 21);
213	<	threadAssertTrue(f.isDone());
214	<	threadAssertTrue(getQueuedTaskCount() == 0);
212	>	assertEquals(21, (int) r);
213	>	assertTrue(f.isDone());
214	>	assertEquals(0, getQueuedTaskCount());
215		return r;
216	<	}
217	<	};
203	<	assertTrue(mainPool.invoke(a) == 21);
216	>	}};
217	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
218		}
219
220
#	Line 208 | Line 222 | public class RecursiveTaskTest extends J
222		* invoke task throws exception when task completes abnormally
223		*/
224		public void testAbnormalInvoke() {
225	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
226	<	public Integer compute() {
225	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
226	>	public Integer realCompute() {
227	>	FailingFibTask f = new FailingFibTask(8);
228		try {
214	–	FailingFibTask f = new FailingFibTask(8);
229		f.invoke();
230		shouldThrow();
231		return NoResult;
232	<	} catch (FJException success) {
219	<	}
232	>	} catch (FJException success) {}
233		return NoResult;
234	<	}
235	<	};
223	<	mainPool.invoke(a);
234	>	}};
235	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
236		}
237
238		/**
239		* quietlyInvoke task returns when task completes abnormally
240		*/
241		public void testAbnormalQuietlyInvoke() {
242	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
243	<	public Integer compute() {
242	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
243	>	public Integer realCompute() {
244		FailingFibTask f = new FailingFibTask(8);
245		f.quietlyInvoke();
246	<	threadAssertTrue(f.isDone());
246	>	assertTrue(f.isDone());
247		return NoResult;
248	<	}
249	<	};
238	<	mainPool.invoke(a);
248	>	}};
249	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
250		}
251
252		/**
253		* join of a forked task throws exception when task completes abnormally
254		*/
255		public void testAbnormalForkJoin() {
256	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
257	<	public Integer compute() {
256	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
257	>	public Integer realCompute() {
258	>	FailingFibTask f = new FailingFibTask(8);
259	>	assertSame(f, f.fork());
260		try {
248	–	FailingFibTask f = new FailingFibTask(8);
249	–	f.fork();
261		Integer r = f.join();
262		shouldThrow();
263		return r;
264	<	} catch (FJException success) {
254	<	}
264	>	} catch (FJException success) {}
265		return NoResult;
266	<	}
267	<	};
258	<	mainPool.invoke(a);
266	>	}};
267	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
268		}
269
270		/**
271		* get of a forked task throws exception when task completes abnormally
272		*/
273		public void testAbnormalForkGet() {
274	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
275	<	public Integer compute() {
274	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
275	>	public Integer realCompute() throws Exception {
276	>	FailingFibTask f = new FailingFibTask(8);
277	>	assertSame(f, f.fork());
278		try {
268	–	FailingFibTask f = new FailingFibTask(8);
269	–	f.fork();
279		Integer r = f.get();
280		shouldThrow();
281		return r;
282	<	} catch (ExecutionException success) {
274	<	} catch (Exception ex) {
275	<	unexpectedException(ex);
276	<	}
282	>	} catch (ExecutionException success) {}
283		return NoResult;
284	<	}
285	<	};
280	<	mainPool.invoke(a);
284	>	}};
285	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
286		}
287
288		/**
289		* timed get of a forked task throws exception when task completes abnormally
290		*/
291		public void testAbnormalForkTimedGet() {
292	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
293	<	public Integer compute() {
292	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
293	>	public Integer realCompute() throws Exception {
294	>	FailingFibTask f = new FailingFibTask(8);
295	>	assertSame(f, f.fork());
296		try {
290	–	FailingFibTask f = new FailingFibTask(8);
291	–	f.fork();
297		Integer r = f.get(5L, TimeUnit.SECONDS);
298		shouldThrow();
299		return r;
300	<	} catch (ExecutionException success) {
296	<	} catch (Exception ex) {
297	<	unexpectedException(ex);
298	<	}
300	>	} catch (ExecutionException success) {}
301		return NoResult;
302	<	}
303	<	};
302	<	mainPool.invoke(a);
302	>	}};
303	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
304		}
305
306		/**
307		* quietlyJoin of a forked task returns when task completes abnormally
308		*/
309		public void testAbnormalForkQuietlyJoin() {
310	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
311	<	public Integer compute() {
310	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
311	>	public Integer realCompute() {
312		FailingFibTask f = new FailingFibTask(8);
313	<	f.fork();
313	>	assertSame(f, f.fork());
314		f.quietlyJoin();
315	<	threadAssertTrue(f.isDone());
316	<	threadAssertTrue(f.isCompletedAbnormally());
317	<	threadAssertTrue(f.getException() instanceof FJException);
315	>	assertTrue(f.isDone());
316	>	assertTrue(f.isCompletedAbnormally());
317	>	assertTrue(f.getException() instanceof FJException);
318		return NoResult;
319	<	}
320	<	};
320	<	mainPool.invoke(a);
319	>	}};
320	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
321		}
322
323		/**
324		* invoke task throws exception when task cancelled
325		*/
326		public void testCancelledInvoke() {
327	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
328	<	public Integer compute() {
327	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
328	>	public Integer realCompute() {
329	>	FibTask f = new FibTask(8);
330	>	assertTrue(f.cancel(true));
331		try {
330	–	FibTask f = new FibTask(8);
331	–	f.cancel(true);
332		Integer r = f.invoke();
333		shouldThrow();
334		return r;
335	<	} catch (CancellationException success) {
336	<	}
335	>	} catch (CancellationException success) {}
336		return NoResult;
337	<	}
338	<	};
340	<	mainPool.invoke(a);
337	>	}};
338	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
339		}
340
341		/**
342		* join of a forked task throws exception when task cancelled
343		*/
344		public void testCancelledForkJoin() {
345	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
346	<	public Integer compute() {
345	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
346	>	public Integer realCompute() {
347	>	FibTask f = new FibTask(8);
348	>	assertTrue(f.cancel(true));
349	>	assertSame(f, f.fork());
350		try {
350	–	FibTask f = new FibTask(8);
351	–	f.cancel(true);
352	–	f.fork();
351		Integer r = f.join();
352		shouldThrow();
353		return r;
354	<	} catch (CancellationException success) {
357	<	}
354	>	} catch (CancellationException success) {}
355		return NoResult;
356	<	}
357	<	};
361	<	mainPool.invoke(a);
356	>	}};
357	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
358		}
359
360		/**
361		* get of a forked task throws exception when task cancelled
362		*/
363		public void testCancelledForkGet() {
364	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
365	<	public Integer compute() {
364	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
365	>	public Integer realCompute() throws Exception {
366	>	FibTask f = new FibTask(8);
367	>	assertTrue(f.cancel(true));
368	>	assertSame(f, f.fork());
369		try {
371	–	FibTask f = new FibTask(8);
372	–	f.cancel(true);
373	–	f.fork();
370		Integer r = f.get();
371		shouldThrow();
372		return r;
373	<	} catch (CancellationException success) {
378	<	} catch (Exception ex) {
379	<	unexpectedException(ex);
380	<	}
373	>	} catch (CancellationException success) {}
374		return NoResult;
375	<	}
376	<	};
384	<	mainPool.invoke(a);
375	>	}};
376	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
377		}
378
379		/**
380		* timed get of a forked task throws exception when task cancelled
381		*/
382		public void testCancelledForkTimedGet() {
383	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
384	<	public Integer compute() {
383	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
384	>	public Integer realCompute() throws Exception {
385	>	FibTask f = new FibTask(8);
386	>	assertTrue(f.cancel(true));
387	>	assertSame(f, f.fork());
388		try {
394	–	FibTask f = new FibTask(8);
395	–	f.cancel(true);
396	–	f.fork();
389		Integer r = f.get(5L, TimeUnit.SECONDS);
390		shouldThrow();
391		return r;
392	<	} catch (CancellationException success) {
401	<	} catch (Exception ex) {
402	<	unexpectedException(ex);
403	<	}
392	>	} catch (CancellationException success) {}
393		return NoResult;
394	<	}
395	<	};
407	<	mainPool.invoke(a);
394	>	}};
395	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
396		}
397
398		/**
399		* quietlyJoin of a forked task returns when task cancelled
400		*/
401		public void testCancelledForkQuietlyJoin() {
402	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
403	<	public Integer compute() {
402	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
403	>	public Integer realCompute() {
404		FibTask f = new FibTask(8);
405	<	f.cancel(true);
406	<	f.fork();
405	>	assertTrue(f.cancel(true));
406	>	assertSame(f, f.fork());
407		f.quietlyJoin();
408	<	threadAssertTrue(f.isDone());
409	<	threadAssertTrue(f.isCompletedAbnormally());
410	<	threadAssertTrue(f.getException() instanceof CancellationException);
408	>	assertTrue(f.isDone());
409	>	assertTrue(f.isCompletedAbnormally());
410	>	assertTrue(f.isCancelled());
411	>	assertTrue(f.getException() instanceof CancellationException);
412		return NoResult;
413	<	}
414	<	};
426	<	mainPool.invoke(a);
413	>	}};
414	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
415		}
416
417		/**
418		* getPool of executing task returns its pool
419		*/
420		public void testGetPool() {
421	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
422	<	public Integer compute() {
423	<	threadAssertTrue(getPool() == mainPool);
421	>	final ForkJoinPool mainPool = mainPool();
422	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
423	>	public Integer realCompute() {
424	>	assertSame(mainPool, getPool());
425		return NoResult;
426	<	}
427	<	};
439	<	mainPool.invoke(a);
426	>	}};
427	>	assertSame(NoResult, testInvokeOnPool(mainPool, a));
428		}
429
430		/**
431		* getPool of non-FJ task returns null
432		*/
433		public void testGetPool2() {
434	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
435	<	public Integer compute() {
436	<	threadAssertTrue(getPool() == null);
434	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
435	>	public Integer realCompute() {
436	>	assertNull(getPool());
437		return NoResult;
438	<	}
439	<	};
452	<	a.invoke();
438	>	}};
439	>	assertSame(NoResult, a.invoke());
440		}
441
442		/**
443		* inForkJoinPool of executing task returns true
444		*/
445		public void testInForkJoinPool() {
446	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
447	<	public Integer compute() {
448	<	threadAssertTrue(inForkJoinPool());
446	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
447	>	public Integer realCompute() {
448	>	assertTrue(inForkJoinPool());
449		return NoResult;
450	<	}
451	<	};
465	<	mainPool.invoke(a);
450	>	}};
451	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
452		}
453
454		/**
455		* inForkJoinPool of non-FJ task returns false
456		*/
457		public void testInForkJoinPool2() {
458	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
459	<	public Integer compute() {
460	<	threadAssertTrue(!inForkJoinPool());
458	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
459	>	public Integer realCompute() {
460	>	assertTrue(!inForkJoinPool());
461		return NoResult;
462	<	}
463	<	};
478	<	a.invoke();
462	>	}};
463	>	assertSame(NoResult, a.invoke());
464		}
465
466		/**
467	<	* setRawResult(null) succeeds
467	>	* The value set by setRawResult is returned by getRawResult
468		*/
469		public void testSetRawResult() {
470	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
471	<	public Integer compute() {
470	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
471	>	public Integer realCompute() {
472		setRawResult(NoResult);
473	+	assertSame(NoResult, getRawResult());
474		return NoResult;
475		}
476		};
477	<	assertEquals(a.invoke(), NoResult);
477	>	a.invoke();
478		}
479
480		/**
481		* A reinitialized task may be re-invoked
482		*/
483		public void testReinitialize() {
484	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
485	<	public Integer compute() {
484	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
485	>	public Integer realCompute() {
486		FibTask f = new FibTask(8);
487		Integer r = f.invoke();
488	<	threadAssertTrue(r == 21);
489	<	threadAssertTrue(f.isDone());
490	<	threadAssertFalse(f.isCancelled());
491	<	threadAssertFalse(f.isCompletedAbnormally());
488	>	assertEquals(21, (int) r);
489	>	assertTrue(f.isDone());
490	>	assertFalse(f.isCancelled());
491	>	assertFalse(f.isCompletedAbnormally());
492		f.reinitialize();
493		r = f.invoke();
494	<	threadAssertTrue(r == 21);
494	>	assertEquals(21, (int) r);
495		return NoResult;
496	<	}
497	<	};
512	<	mainPool.invoke(a);
496	>	}};
497	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
498		}
499
500		/**
501		* invoke task throws exception after invoking completeExceptionally
502		*/
503		public void testCompleteExceptionally() {
504	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
505	<	public Integer compute() {
504	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
505	>	public Integer realCompute() {
506	>	FibTask f = new FibTask(8);
507	>	f.completeExceptionally(new FJException());
508		try {
522	–	FibTask f = new FibTask(8);
523	–	f.completeExceptionally(new FJException());
509		Integer r = f.invoke();
510		shouldThrow();
511		return r;
512	<	} catch (FJException success) {
528	<	}
512	>	} catch (FJException success) {}
513		return NoResult;
514	<	}
515	<	};
532	<	mainPool.invoke(a);
514	>	}};
515	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
516		}
517
518		/**
519		* invoke task suppresses execution invoking complete
520		*/
521		public void testComplete() {
522	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
523	<	public Integer compute() {
522	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
523	>	public Integer realCompute() {
524		FibTask f = new FibTask(8);
525		f.complete(NoResult);
526		Integer r = f.invoke();
527	<	threadAssertTrue(f.isDone());
528	<	threadAssertTrue(r == NoResult);
527	>	assertTrue(f.isDone());
528	>	assertSame(NoResult, r);
529		return r;
530	<	}
531	<	};
549	<	mainPool.invoke(a);
530	>	}};
531	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
532		}
533
534		/**
535		* invokeAll(t1, t2) invokes all task arguments
536		*/
537		public void testInvokeAll2() {
538	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
539	<	public Integer compute() {
538	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
539	>	public Integer realCompute() {
540		FibTask f = new FibTask(8);
541		FibTask g = new FibTask(9);
542		invokeAll(f, g);
543	<	threadAssertTrue(f.isDone());
544	<	threadAssertTrue(f.join() == 21);
545	<	threadAssertTrue(g.isDone());
546	<	threadAssertTrue(g.join() == 34);
543	>	assertTrue(f.isDone());
544	>	assertEquals(21, (int) f.join());
545	>	assertTrue(g.isDone());
546	>	assertEquals(34, (int) g.join());
547		return NoResult;
548	<	}
549	<	};
568	<	mainPool.invoke(a);
548	>	}};
549	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
550		}
551
552		/**
553		* invokeAll(tasks) with 1 argument invokes task
554		*/
555		public void testInvokeAll1() {
556	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
557	<	public Integer compute() {
556	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
557	>	public Integer realCompute() {
558		FibTask f = new FibTask(8);
559		invokeAll(f);
560	<	threadAssertTrue(f.isDone());
561	<	threadAssertTrue(f.join() == 21);
560	>	assertTrue(f.isDone());
561	>	assertEquals(21, (int) f.join());
562		return NoResult;
563	<	}
564	<	};
584	<	mainPool.invoke(a);
563	>	}};
564	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
565		}
566
567		/**
568		* invokeAll(tasks) with > 2 argument invokes tasks
569		*/
570		public void testInvokeAll3() {
571	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
572	<	public Integer compute() {
571	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
572	>	public Integer realCompute() {
573		FibTask f = new FibTask(8);
574		FibTask g = new FibTask(9);
575		FibTask h = new FibTask(7);
576		invokeAll(f, g, h);
577	<	threadAssertTrue(f.isDone());
578	<	threadAssertTrue(f.join() == 21);
579	<	threadAssertTrue(g.isDone());
580	<	threadAssertTrue(g.join() == 34);
581	<	threadAssertTrue(h.isDone());
582	<	threadAssertTrue(h.join() == 13);
577	>	assertTrue(f.isDone());
578	>	assertEquals(21, (int) f.join());
579	>	assertTrue(g.isDone());
580	>	assertEquals(34, (int) g.join());
581	>	assertTrue(h.isDone());
582	>	assertEquals(13, (int) h.join());
583		return NoResult;
584	<	}
585	<	};
606	<	mainPool.invoke(a);
584	>	}};
585	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
586		}
587
588		/**
589		* invokeAll(collection) invokes all tasks in the collection
590		*/
591		public void testInvokeAllCollection() {
592	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
593	<	public Integer compute() {
592	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
593	>	public Integer realCompute() {
594		FibTask f = new FibTask(8);
595		FibTask g = new FibTask(9);
596		FibTask h = new FibTask(7);
#	Line 620 | Line 599 | public class RecursiveTaskTest extends J
599		set.add(g);
600		set.add(h);
601		invokeAll(set);
602	<	threadAssertTrue(f.isDone());
603	<	threadAssertTrue(f.join() == 21);
604	<	threadAssertTrue(g.isDone());
605	<	threadAssertTrue(g.join() == 34);
606	<	threadAssertTrue(h.isDone());
607	<	threadAssertTrue(h.join() == 13);
602	>	assertTrue(f.isDone());
603	>	assertEquals(21, (int) f.join());
604	>	assertTrue(g.isDone());
605	>	assertEquals(34, (int) g.join());
606	>	assertTrue(h.isDone());
607	>	assertEquals(13, (int) h.join());
608		return NoResult;
609	<	}
610	<	};
632	<	mainPool.invoke(a);
609	>	}};
610	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
611		}
612
613
#	Line 637 | Line 615 | public class RecursiveTaskTest extends J
615		* invokeAll(t1, t2) throw exception if any task does
616		*/
617		public void testAbnormalInvokeAll2() {
618	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
619	<	public Integer compute() {
618	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
619	>	public Integer realCompute() {
620	>	FibTask f = new FibTask(8);
621	>	FailingFibTask g = new FailingFibTask(9);
622		try {
643	–	FibTask f = new FibTask(8);
644	–	FailingFibTask g = new FailingFibTask(9);
623		invokeAll(f, g);
624		shouldThrow();
625		return NoResult;
626	<	} catch (FJException success) {
649	<	}
626	>	} catch (FJException success) {}
627		return NoResult;
628	<	}
629	<	};
653	<	mainPool.invoke(a);
628	>	}};
629	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
630		}
631
632		/**
633		* invokeAll(tasks) with 1 argument throws exception if task does
634		*/
635		public void testAbnormalInvokeAll1() {
636	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
637	<	public Integer compute() {
636	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
637	>	public Integer realCompute() {
638	>	FailingFibTask g = new FailingFibTask(9);
639		try {
663	–	FailingFibTask g = new FailingFibTask(9);
640		invokeAll(g);
641		shouldThrow();
642		return NoResult;
643	<	} catch (FJException success) {
668	<	}
643	>	} catch (FJException success) {}
644		return NoResult;
645	<	}
646	<	};
672	<	mainPool.invoke(a);
645	>	}};
646	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
647		}
648
649		/**
650		* invokeAll(tasks) with > 2 argument throws exception if any task does
651		*/
652		public void testAbnormalInvokeAll3() {
653	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
654	<	public Integer compute() {
653	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
654	>	public Integer realCompute() {
655	>	FibTask f = new FibTask(8);
656	>	FailingFibTask g = new FailingFibTask(9);
657	>	FibTask h = new FibTask(7);
658		try {
682	–	FibTask f = new FibTask(8);
683	–	FailingFibTask g = new FailingFibTask(9);
684	–	FibTask h = new FibTask(7);
659		invokeAll(f, g, h);
660		shouldThrow();
661		return NoResult;
662	<	} catch (FJException success) {
689	<	}
662	>	} catch (FJException success) {}
663		return NoResult;
664	<	}
665	<	};
693	<	mainPool.invoke(a);
664	>	}};
665	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
666		}
667
668		/**
669		* invokeAll(collection) throws exception if any task does
670		*/
671		public void testAbnormalInvokeAllCollection() {
672	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
673	<	public Integer compute() {
672	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
673	>	public Integer realCompute() {
674	>	FailingFibTask f = new FailingFibTask(8);
675	>	FibTask g = new FibTask(9);
676	>	FibTask h = new FibTask(7);
677	>	HashSet set = new HashSet();
678	>	set.add(f);
679	>	set.add(g);
680	>	set.add(h);
681		try {
703	–	FailingFibTask f = new FailingFibTask(8);
704	–	FibTask g = new FibTask(9);
705	–	FibTask h = new FibTask(7);
706	–	HashSet set = new HashSet();
707	–	set.add(f);
708	–	set.add(g);
709	–	set.add(h);
682		invokeAll(set);
683		shouldThrow();
684		return NoResult;
685	<	} catch (FJException success) {
714	<	}
685	>	} catch (FJException success) {}
686		return NoResult;
687	<	}
688	<	};
718	<	mainPool.invoke(a);
687	>	}};
688	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
689		}
690
691		/**
#	Line 723 | Line 693 | public class RecursiveTaskTest extends J
693		* and suppresses execution
694		*/
695		public void testTryUnfork() {
696	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
697	<	public Integer compute() {
696	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
697	>	public Integer realCompute() {
698		FibTask g = new FibTask(9);
699	<	g.fork();
699	>	assertSame(g, g.fork());
700		FibTask f = new FibTask(8);
701	<	f.fork();
702	<	threadAssertTrue(f.tryUnfork());
701	>	assertSame(f, f.fork());
702	>	assertTrue(f.tryUnfork());
703		helpQuiesce();
704	<	threadAssertFalse(f.isDone());
705	<	threadAssertTrue(g.isDone());
704	>	assertFalse(f.isDone());
705	>	assertTrue(g.isDone());
706		return NoResult;
707	<	}
708	<	};
739	<	singletonPool.invoke(a);
707	>	}};
708	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
709		}
710
711		/**
#	Line 744 | Line 713 | public class RecursiveTaskTest extends J
713		* there are more tasks than threads
714		*/
715		public void testGetSurplusQueuedTaskCount() {
716	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
717	<	public Integer compute() {
716	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
717	>	public Integer realCompute() {
718		FibTask h = new FibTask(7);
719	<	h.fork();
719	>	assertSame(h, h.fork());
720		FibTask g = new FibTask(9);
721	<	g.fork();
721	>	assertSame(g, g.fork());
722		FibTask f = new FibTask(8);
723	<	f.fork();
724	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
723	>	assertSame(f, f.fork());
724	>	assertTrue(getSurplusQueuedTaskCount() > 0);
725		helpQuiesce();
726		return NoResult;
727	<	}
728	<	};
760	<	singletonPool.invoke(a);
727	>	}};
728	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
729		}
730
731		/**
732		* peekNextLocalTask returns most recent unexecuted task.
733		*/
734		public void testPeekNextLocalTask() {
735	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
736	<	public Integer compute() {
735	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
736	>	public Integer realCompute() {
737		FibTask g = new FibTask(9);
738	<	g.fork();
738	>	assertSame(g, g.fork());
739		FibTask f = new FibTask(8);
740	<	f.fork();
741	<	threadAssertTrue(peekNextLocalTask() == f);
742	<	f.join();
743	<	threadAssertTrue(f.isDone());
740	>	assertSame(f, f.fork());
741	>	assertSame(f, peekNextLocalTask());
742	>	assertEquals(21, (int) f.join());
743	>	assertTrue(f.isDone());
744		helpQuiesce();
745		return NoResult;
746	<	}
747	<	};
780	<	singletonPool.invoke(a);
746	>	}};
747	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
748		}
749
750		/**
#	Line 785 | Line 752 | public class RecursiveTaskTest extends J
752		* without executing it
753		*/
754		public void testPollNextLocalTask() {
755	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
756	<	public Integer compute() {
755	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
756	>	public Integer realCompute() {
757		FibTask g = new FibTask(9);
758	<	g.fork();
758	>	assertSame(g, g.fork());
759		FibTask f = new FibTask(8);
760	<	f.fork();
761	<	threadAssertTrue(pollNextLocalTask() == f);
760	>	assertSame(f, f.fork());
761	>	assertSame(f, pollNextLocalTask());
762		helpQuiesce();
763	<	threadAssertFalse(f.isDone());
763	>	assertFalse(f.isDone());
764		return NoResult;
765	<	}
766	<	};
800	<	singletonPool.invoke(a);
765	>	}};
766	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
767		}
768
769		/**
770	<	* pollTask returns an unexecuted task
805	<	* without executing it
770	>	* pollTask returns an unexecuted task without executing it
771		*/
772		public void testPollTask() {
773	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
774	<	public Integer compute() {
773	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
774	>	public Integer realCompute() {
775		FibTask g = new FibTask(9);
776	<	g.fork();
776	>	assertSame(g, g.fork());
777		FibTask f = new FibTask(8);
778	<	f.fork();
779	<	threadAssertTrue(pollTask() == f);
778	>	assertSame(f, f.fork());
779	>	assertSame(f, pollTask());
780		helpQuiesce();
781	<	threadAssertFalse(f.isDone());
782	<	threadAssertTrue(g.isDone());
781	>	assertFalse(f.isDone());
782	>	assertTrue(g.isDone());
783		return NoResult;
784	<	}
785	<	};
821	<	singletonPool.invoke(a);
784	>	}};
785	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
786		}
787
788		/**
789		* peekNextLocalTask returns least recent unexecuted task in async mode
790		*/
791		public void testPeekNextLocalTaskAsync() {
792	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
793	<	public Integer compute() {
792	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
793	>	public Integer realCompute() {
794		FibTask g = new FibTask(9);
795	<	g.fork();
795	>	assertSame(g, g.fork());
796		FibTask f = new FibTask(8);
797	<	f.fork();
798	<	threadAssertTrue(peekNextLocalTask() == g);
799	<	f.join();
797	>	assertSame(f, f.fork());
798	>	assertSame(g, peekNextLocalTask());
799	>	assertEquals(21, (int) f.join());
800		helpQuiesce();
801	<	threadAssertTrue(f.isDone());
801	>	assertTrue(f.isDone());
802		return NoResult;
803	<	}
804	<	};
841	<	asyncSingletonPool.invoke(a);
803	>	}};
804	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
805		}
806
807		/**
#	Line 846 | Line 809 | public class RecursiveTaskTest extends J
809		* without executing it, in async mode
810		*/
811		public void testPollNextLocalTaskAsync() {
812	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
813	<	public Integer compute() {
812	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
813	>	public Integer realCompute() {
814		FibTask g = new FibTask(9);
815	<	g.fork();
815	>	assertSame(g, g.fork());
816		FibTask f = new FibTask(8);
817	<	f.fork();
818	<	threadAssertTrue(pollNextLocalTask() == g);
817	>	assertSame(f, f.fork());
818	>	assertSame(g, pollNextLocalTask());
819		helpQuiesce();
820	<	threadAssertTrue(f.isDone());
821	<	threadAssertFalse(g.isDone());
820	>	assertTrue(f.isDone());
821	>	assertFalse(g.isDone());
822		return NoResult;
823	<	}
824	<	};
862	<	asyncSingletonPool.invoke(a);
823	>	}};
824	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
825		}
826
827		/**
#	Line 867 | Line 829 | public class RecursiveTaskTest extends J
829		* without executing it, in async mode
830		*/
831		public void testPollTaskAsync() {
832	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
833	<	public Integer compute() {
832	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
833	>	public Integer realCompute() {
834		FibTask g = new FibTask(9);
835	<	g.fork();
835	>	assertSame(g, g.fork());
836		FibTask f = new FibTask(8);
837	<	f.fork();
838	<	threadAssertTrue(pollTask() == g);
837	>	assertSame(f, f.fork());
838	>	assertSame(g, pollTask());
839		helpQuiesce();
840	<	threadAssertTrue(f.isDone());
841	<	threadAssertFalse(g.isDone());
840	>	assertTrue(f.isDone());
841	>	assertFalse(g.isDone());
842		return NoResult;
843	<	}
844	<	};
883	<	asyncSingletonPool.invoke(a);
843	>	}};
844	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
845		}
846
847		}

Diff Legend

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