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.18 by jsr166, Tue Sep 14 18:38:28 2010 UTC vs.
Revision 1.19 by jsr166, Thu Sep 16 00:52:49 2010 UTC

#	Line 37 | Line 37 | public class RecursiveTaskTest extends J
37
38		private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
39		try {
40	<	return pool.invoke(a);
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		}
#	Line 51 | 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 65 | 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 86 | Line 98 | public class RecursiveTaskTest extends J
98		* returns value;
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	<	}
100	<	};
111	>	}};
112		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
113		}
114
#	Line 107 | 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	<	}
121	<	};
131	>	}};
132		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
133		}
134
#	Line 126 | Line 136 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, 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	<	}
138	<	};
147	>	}};
148		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
149		}
150
#	Line 143 | Line 152 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, f.fork());
160	<	Integer r = f.get();
161	<	threadAssertTrue(r == 21);
162	<	threadAssertTrue(f.isDone());
163	<	return r;
155	<	} catch (Exception ex) {
156	<	unexpectedException(ex);
157	<	}
158	<	return NoResult;
159	<	}
160	<	};
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
#	Line 165 | Line 168 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, f.fork());
176	<	Integer r = f.get(5L, TimeUnit.SECONDS);
177	<	threadAssertTrue(r == 21);
178	<	threadAssertTrue(f.isDone());
179	<	return r;
177	<	} catch (Exception ex) {
178	<	unexpectedException(ex);
179	<	}
180	<	return NoResult;
181	<	}
182	<	};
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
#	Line 187 | Line 184 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, 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	<	}
200	<	};
196	>	}};
197		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
198		}
199
#	Line 207 | 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	<	threadAssertSame(f, 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	<	}
221	<	};
216	>	}};
217		assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
218		}
219
#	Line 227 | 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 {
233	–	FailingFibTask f = new FailingFibTask(8);
229		f.invoke();
230		shouldThrow();
231		return NoResult;
232	<	} catch (FJException success) {
238	<	}
232	>	} catch (FJException success) {}
233		return NoResult;
234	<	}
241	<	};
234	>	}};
235		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
236		}
237
#	Line 246 | Line 239 | public class RecursiveTaskTest extends J
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	<	}
256	<	};
248	>	}};
249		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
250		}
251
#	Line 261 | Line 253 | public class RecursiveTaskTest extends J
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 {
267	–	FailingFibTask f = new FailingFibTask(8);
268	–	threadAssertSame(f, f.fork());
261		Integer r = f.join();
262		shouldThrow();
263		return r;
264	<	} catch (FJException success) {
273	<	}
264	>	} catch (FJException success) {}
265		return NoResult;
266	<	}
276	<	};
266	>	}};
267		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
268		}
269
#	Line 281 | Line 271 | public class RecursiveTaskTest extends J
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 {
287	–	FailingFibTask f = new FailingFibTask(8);
288	–	threadAssertSame(f, f.fork());
279		Integer r = f.get();
280		shouldThrow();
281		return r;
282	<	} catch (ExecutionException success) {
293	<	} catch (Exception ex) {
294	<	unexpectedException(ex);
295	<	}
282	>	} catch (ExecutionException success) {}
283		return NoResult;
284	<	}
298	<	};
284	>	}};
285		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
286		}
287
#	Line 303 | Line 289 | public class RecursiveTaskTest extends J
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 {
309	–	FailingFibTask f = new FailingFibTask(8);
310	–	threadAssertSame(f, f.fork());
297		Integer r = f.get(5L, TimeUnit.SECONDS);
298		shouldThrow();
299		return r;
300	<	} catch (ExecutionException success) {
315	<	} catch (Exception ex) {
316	<	unexpectedException(ex);
317	<	}
300	>	} catch (ExecutionException success) {}
301		return NoResult;
302	<	}
320	<	};
302	>	}};
303		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
304		}
305
#	Line 325 | Line 307 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(f, 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	<	}
338	<	};
319	>	}};
320		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
321		}
322
#	Line 343 | Line 324 | public class RecursiveTaskTest extends J
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 {
349	–	FibTask f = new FibTask(8);
350	–	threadAssertTrue(f.cancel(true));
332		Integer r = f.invoke();
333		shouldThrow();
334		return r;
335	<	} catch (CancellationException success) {
355	<	}
335	>	} catch (CancellationException success) {}
336		return NoResult;
337	<	}
358	<	};
337	>	}};
338		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
339		}
340
#	Line 363 | Line 342 | public class RecursiveTaskTest extends J
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 {
369	–	FibTask f = new FibTask(8);
370	–	threadAssertTrue(f.cancel(true));
371	–	threadAssertSame(f, f.fork());
351		Integer r = f.join();
352		shouldThrow();
353		return r;
354	<	} catch (CancellationException success) {
376	<	}
354	>	} catch (CancellationException success) {}
355		return NoResult;
356	<	}
379	<	};
356	>	}};
357		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
358		}
359
#	Line 384 | Line 361 | public class RecursiveTaskTest extends J
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 {
390	–	FibTask f = new FibTask(8);
391	–	threadAssertTrue(f.cancel(true));
392	–	threadAssertSame(f, f.fork());
370		Integer r = f.get();
371		shouldThrow();
372		return r;
373	<	} catch (CancellationException success) {
397	<	} catch (Exception ex) {
398	<	unexpectedException(ex);
399	<	}
373	>	} catch (CancellationException success) {}
374		return NoResult;
375	<	}
402	<	};
375	>	}};
376		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
377		}
378
#	Line 407 | Line 380 | public class RecursiveTaskTest extends J
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 {
413	–	FibTask f = new FibTask(8);
414	–	threadAssertTrue(f.cancel(true));
415	–	threadAssertSame(f, f.fork());
389		Integer r = f.get(5L, TimeUnit.SECONDS);
390		shouldThrow();
391		return r;
392	<	} catch (CancellationException success) {
420	<	} catch (Exception ex) {
421	<	unexpectedException(ex);
422	<	}
392	>	} catch (CancellationException success) {}
393		return NoResult;
394	<	}
425	<	};
394	>	}};
395		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
396		}
397
#	Line 430 | Line 399 | public class RecursiveTaskTest extends J
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	<	threadAssertTrue(f.cancel(true));
406	<	threadAssertSame(f, 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	<	}
444	<	};
413	>	}};
414		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
415		}
416
#	Line 450 | Line 419 | public class RecursiveTaskTest extends J
419		*/
420		public void testGetPool() {
421		final ForkJoinPool mainPool = mainPool();
422	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
423	<	public Integer compute() {
424	<	threadAssertTrue(getPool() == mainPool);
422	>	RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
423	>	public Integer realCompute() {
424	>	assertSame(mainPool, getPool());
425		return NoResult;
426	<	}
458	<	};
426	>	}};
427		assertSame(NoResult, testInvokeOnPool(mainPool, a));
428		}
429
#	Line 463 | Line 431 | public class RecursiveTaskTest extends J
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	<	}
471	<	};
438	>	}};
439		assertSame(NoResult, a.invoke());
440		}
441
#	Line 476 | Line 443 | public class RecursiveTaskTest extends J
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	<	}
484	<	};
450	>	}};
451		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
452		}
453
#	Line 489 | Line 455 | public class RecursiveTaskTest extends J
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	<	}
497	<	};
462	>	}};
463		assertSame(NoResult, a.invoke());
464		}
465
#	Line 502 | Line 467 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(NoResult, getRawResult());
473	>	assertSame(NoResult, getRawResult());
474		return NoResult;
475		}
476		};
#	Line 516 | Line 481 | public class RecursiveTaskTest extends J
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	<	}
532	<	};
496	>	}};
497		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
498		}
499
#	Line 537 | Line 501 | public class RecursiveTaskTest extends J
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 {
543	–	FibTask f = new FibTask(8);
544	–	f.completeExceptionally(new FJException());
509		Integer r = f.invoke();
510		shouldThrow();
511		return r;
512	<	} catch (FJException success) {
549	<	}
512	>	} catch (FJException success) {}
513		return NoResult;
514	<	}
552	<	};
514	>	}};
515		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
516		}
517
#	Line 557 | Line 519 | public class RecursiveTaskTest extends J
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	<	}
569	<	};
530	>	}};
531		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
532		}
533
#	Line 574 | Line 535 | public class RecursiveTaskTest extends J
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	<	}
588	<	};
548	>	}};
549		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
550		}
551
#	Line 593 | Line 553 | public class RecursiveTaskTest extends J
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	<	}
604	<	};
563	>	}};
564		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
565		}
566
#	Line 609 | Line 568 | public class RecursiveTaskTest extends J
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	<	}
626	<	};
584	>	}};
585		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
586		}
587
#	Line 631 | Line 589 | public class RecursiveTaskTest extends J
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 641 | 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	<	}
652	<	};
609	>	}};
610		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
611		}
612
#	Line 658 | 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 {
664	–	FibTask f = new FibTask(8);
665	–	FailingFibTask g = new FailingFibTask(9);
623		invokeAll(f, g);
624		shouldThrow();
625		return NoResult;
626	<	} catch (FJException success) {
670	<	}
626	>	} catch (FJException success) {}
627		return NoResult;
628	<	}
673	<	};
628	>	}};
629		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
630		}
631
#	Line 678 | Line 633 | public class RecursiveTaskTest extends J
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 {
684	–	FailingFibTask g = new FailingFibTask(9);
640		invokeAll(g);
641		shouldThrow();
642		return NoResult;
643	<	} catch (FJException success) {
689	<	}
643	>	} catch (FJException success) {}
644		return NoResult;
645	<	}
692	<	};
645	>	}};
646		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
647		}
648
#	Line 697 | Line 650 | public class RecursiveTaskTest extends J
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 {
703	–	FibTask f = new FibTask(8);
704	–	FailingFibTask g = new FailingFibTask(9);
705	–	FibTask h = new FibTask(7);
659		invokeAll(f, g, h);
660		shouldThrow();
661		return NoResult;
662	<	} catch (FJException success) {
710	<	}
662	>	} catch (FJException success) {}
663		return NoResult;
664	<	}
713	<	};
664	>	}};
665		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
666		}
667
#	Line 718 | Line 669 | public class RecursiveTaskTest extends J
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 {
724	–	FailingFibTask f = new FailingFibTask(8);
725	–	FibTask g = new FibTask(9);
726	–	FibTask h = new FibTask(7);
727	–	HashSet set = new HashSet();
728	–	set.add(f);
729	–	set.add(g);
730	–	set.add(h);
682		invokeAll(set);
683		shouldThrow();
684		return NoResult;
685	<	} catch (FJException success) {
735	<	}
685	>	} catch (FJException success) {}
686		return NoResult;
687	<	}
738	<	};
687	>	}};
688		assertSame(NoResult, testInvokeOnPool(mainPool(), a));
689		}
690
#	Line 744 | 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	<	threadAssertSame(g, g.fork());
699	>	assertSame(g, g.fork());
700		FibTask f = new FibTask(8);
701	<	threadAssertSame(f, 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	<	}
759	<	};
707	>	}};
708		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
709		}
710
#	Line 765 | 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	<	threadAssertSame(h, h.fork());
719	>	assertSame(h, h.fork());
720		FibTask g = new FibTask(9);
721	<	threadAssertSame(g, g.fork());
721	>	assertSame(g, g.fork());
722		FibTask f = new FibTask(8);
723	<	threadAssertSame(f, f.fork());
724	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
723	>	assertSame(f, f.fork());
724	>	assertTrue(getSurplusQueuedTaskCount() > 0);
725		helpQuiesce();
726		return NoResult;
727	<	}
780	<	};
727	>	}};
728		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
729		}
730
#	Line 785 | Line 732 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(g, g.fork());
738	>	assertSame(g, g.fork());
739		FibTask f = new FibTask(8);
740	<	threadAssertSame(f, f.fork());
741	<	threadAssertTrue(peekNextLocalTask() == f);
742	<	threadAssertTrue(f.join() == 21);
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	<	}
800	<	};
746	>	}};
747		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
748		}
749
#	Line 806 | 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	<	threadAssertSame(g, g.fork());
758	>	assertSame(g, g.fork());
759		FibTask f = new FibTask(8);
760	<	threadAssertSame(f, 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	<	}
820	<	};
765	>	}};
766		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
767		}
768
#	Line 825 | Line 770 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(g, g.fork());
776	>	assertSame(g, g.fork());
777		FibTask f = new FibTask(8);
778	<	threadAssertSame(f, 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	<	}
840	<	};
784	>	}};
785		assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
786		}
787
#	Line 845 | Line 789 | public class RecursiveTaskTest extends J
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	<	threadAssertSame(g, g.fork());
795	>	assertSame(g, g.fork());
796		FibTask f = new FibTask(8);
797	<	threadAssertSame(f, f.fork());
798	<	threadAssertTrue(peekNextLocalTask() == g);
799	<	threadAssertEquals(21, (int) 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	<	}
860	<	};
803	>	}};
804		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
805		}
806
#	Line 866 | 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	<	threadAssertSame(g, g.fork());
815	>	assertSame(g, g.fork());
816		FibTask f = new FibTask(8);
817	<	threadAssertSame(f, 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	<	}
881	<	};
823	>	}};
824		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
825		}
826
#	Line 887 | 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	<	threadAssertSame(g, g.fork());
835	>	assertSame(g, g.fork());
836		FibTask f = new FibTask(8);
837	<	threadAssertSame(f, 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	<	}
902	<	};
843	>	}};
844		assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
845		}
846

Diff Legend

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