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.17 by dl, Wed Sep 15 12:46:57 2010 UTC vs.
Revision 1.18 by jsr166, Thu Sep 16 00:52:49 2010 UTC

#	Line 39 | Line 39 | public class RecursiveActionTest extends
39
40		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
41		try {
42	<	assertTrue(pool.invoke(a) == null);
42	>	assertFalse(a.isDone());
43	>	assertFalse(a.isCompletedNormally());
44	>	assertFalse(a.isCompletedAbnormally());
45	>	assertFalse(a.isCancelled());
46	>	assertNull(a.getException());
47	>
48	>	assertNull(pool.invoke(a));
49	>
50	>	assertTrue(a.isDone());
51	>	assertTrue(a.isCompletedNormally());
52	>	assertFalse(a.isCompletedAbnormally());
53	>	assertFalse(a.isCancelled());
54	>	assertNull(a.getException());
55		} finally {
56		joinPool(pool);
57		}
#	Line 50 | Line 62 | public class RecursiveActionTest extends
62		}
63
64		// A simple recursive action for testing
65	<	static final class FibAction extends RecursiveAction {
65	>	final class FibAction extends CheckedRecursiveAction {
66		final int number;
67		int result;
68		FibAction(int n) { number = n; }
69	<	public void compute() {
69	>	public void realCompute() {
70		int n = number;
71		if (n <= 1)
72		result = n;
#	Line 91 | Line 103 | public class RecursiveActionTest extends
103		* completed tasks. getRawResult of a RecursiveAction returns null;
104		*/
105		public void testInvoke() {
106	<	RecursiveAction a = new RecursiveAction() {
107	<	public void compute() {
106	>	RecursiveAction a = new CheckedRecursiveAction() {
107	>	public void realCompute() {
108		FibAction f = new FibAction(8);
109	<	threadAssertNull(f.invoke());
110	<	threadAssertTrue(f.result == 21);
111	<	threadAssertTrue(f.isDone());
112	<	threadAssertFalse(f.isCancelled());
113	<	threadAssertFalse(f.isCompletedAbnormally());
114	<	threadAssertTrue(f.getRawResult() == null);
109	>	assertNull(f.invoke());
110	>	assertEquals(21, f.result);
111	>	assertTrue(f.isDone());
112	>	assertFalse(f.isCancelled());
113	>	assertFalse(f.isCompletedAbnormally());
114	>	assertNull(f.getRawResult());
115		}};
116		testInvokeOnPool(mainPool(), a);
117		}
#	Line 110 | Line 122 | public class RecursiveActionTest extends
122		* completed tasks
123		*/
124		public void testQuietlyInvoke() {
125	<	RecursiveAction a = new RecursiveAction() {
126	<	public void compute() {
125	>	RecursiveAction a = new CheckedRecursiveAction() {
126	>	public void realCompute() {
127		FibAction f = new FibAction(8);
128		f.quietlyInvoke();
129	<	threadAssertTrue(f.result == 21);
130	<	threadAssertTrue(f.isDone());
131	<	threadAssertFalse(f.isCancelled());
132	<	threadAssertFalse(f.isCompletedAbnormally());
133	<	threadAssertTrue(f.getRawResult() == null);
129	>	assertEquals(21, f.result);
130	>	assertTrue(f.isDone());
131	>	assertFalse(f.isCancelled());
132	>	assertFalse(f.isCompletedAbnormally());
133	>	assertNull(f.getRawResult());
134		}};
135		testInvokeOnPool(mainPool(), a);
136		}
#	Line 127 | Line 139 | public class RecursiveActionTest extends
139		* join of a forked task returns when task completes
140		*/
141		public void testForkJoin() {
142	<	RecursiveAction a = new RecursiveAction() {
143	<	public void compute() {
142	>	RecursiveAction a = new CheckedRecursiveAction() {
143	>	public void realCompute() {
144		FibAction f = new FibAction(8);
145	<	threadAssertSame(f, f.fork());
146	<	threadAssertNull(f.join());
147	<	threadAssertTrue(f.result == 21);
148	<	threadAssertTrue(f.isDone());
149	<	threadAssertTrue(f.getRawResult() == null);
145	>	assertSame(f, f.fork());
146	>	assertNull(f.join());
147	>	assertEquals(21, f.result);
148	>	assertTrue(f.isDone());
149	>	assertNull(f.getRawResult());
150		}};
151		testInvokeOnPool(mainPool(), a);
152		}
#	Line 143 | Line 155 | public class RecursiveActionTest extends
155		* get of a forked task returns when task completes
156		*/
157		public void testForkGet() {
158	<	RecursiveAction a = new RecursiveAction() {
159	<	public void compute() {
160	<	try {
161	<	FibAction f = new FibAction(8);
162	<	threadAssertSame(f, f.fork());
163	<	threadAssertNull(f.get());
164	<	threadAssertTrue(f.result == 21);
153	<	threadAssertTrue(f.isDone());
154	<	} catch (Exception ex) {
155	<	unexpectedException(ex);
156	<	}
158	>	RecursiveAction a = new CheckedRecursiveAction() {
159	>	public void realCompute() throws Exception {
160	>	FibAction f = new FibAction(8);
161	>	assertSame(f, f.fork());
162	>	assertNull(f.get());
163	>	assertEquals(21, f.result);
164	>	assertTrue(f.isDone());
165		}};
166		testInvokeOnPool(mainPool(), a);
167		}
#	Line 162 | Line 170 | public class RecursiveActionTest extends
170		* timed get of a forked task returns when task completes
171		*/
172		public void testForkTimedGet() {
173	<	RecursiveAction a = new RecursiveAction() {
174	<	public void compute() {
175	<	try {
176	<	FibAction f = new FibAction(8);
177	<	threadAssertSame(f, f.fork());
178	<	threadAssertNull(f.get(5L, TimeUnit.SECONDS));
179	<	threadAssertTrue(f.result == 21);
172	<	threadAssertTrue(f.isDone());
173	<	} catch (Exception ex) {
174	<	unexpectedException(ex);
175	<	}
173	>	RecursiveAction a = new CheckedRecursiveAction() {
174	>	public void realCompute() throws Exception {
175	>	FibAction f = new FibAction(8);
176	>	assertSame(f, f.fork());
177	>	assertNull(f.get(5L, TimeUnit.SECONDS));
178	>	assertEquals(21, f.result);
179	>	assertTrue(f.isDone());
180		}};
181		testInvokeOnPool(mainPool(), a);
182		}
#	Line 181 | Line 185 | public class RecursiveActionTest extends
185		* timed get with null time unit throws NPE
186		*/
187		public void testForkTimedGetNPE() {
188	<	RecursiveAction a = new RecursiveAction() {
189	<	public void compute() {
188	>	RecursiveAction a = new CheckedRecursiveAction() {
189	>	public void realCompute() throws Exception {
190	>	FibAction f = new FibAction(8);
191	>	assertSame(f, f.fork());
192		try {
187	–	FibAction f = new FibAction(8);
188	–	threadAssertSame(f, f.fork());
193		f.get(5L, null);
194		shouldThrow();
195	<	} catch (NullPointerException success) {
192	<	} catch (Exception ex) {
193	<	unexpectedException(ex);
194	<	}
195	>	} catch (NullPointerException success) {}
196		}};
197		testInvokeOnPool(mainPool(), a);
198		}
#	Line 200 | Line 201 | public class RecursiveActionTest extends
201		* quietlyJoin of a forked task returns when task completes
202		*/
203		public void testForkQuietlyJoin() {
204	<	RecursiveAction a = new RecursiveAction() {
205	<	public void compute() {
204	>	RecursiveAction a = new CheckedRecursiveAction() {
205	>	public void realCompute() {
206		FibAction f = new FibAction(8);
207	<	threadAssertSame(f, f.fork());
207	>	assertSame(f, f.fork());
208		f.quietlyJoin();
209	<	threadAssertTrue(f.result == 21);
210	<	threadAssertTrue(f.isDone());
209	>	assertEquals(21, f.result);
210	>	assertTrue(f.isDone());
211		}};
212		testInvokeOnPool(mainPool(), a);
213		}
#	Line 217 | Line 218 | public class RecursiveActionTest extends
218		* getQueuedTaskCount returns 0 when quiescent
219		*/
220		public void testForkHelpQuiesce() {
221	<	RecursiveAction a = new RecursiveAction() {
222	<	public void compute() {
221	>	RecursiveAction a = new CheckedRecursiveAction() {
222	>	public void realCompute() {
223		FibAction f = new FibAction(8);
224	<	threadAssertSame(f, f.fork());
224	>	assertSame(f, f.fork());
225		f.helpQuiesce();
226	<	threadAssertTrue(f.result == 21);
227	<	threadAssertTrue(f.isDone());
228	<	threadAssertTrue(getQueuedTaskCount() == 0);
226	>	assertEquals(21, f.result);
227	>	assertTrue(f.isDone());
228	>	assertEquals(0, getQueuedTaskCount());
229		}};
230		testInvokeOnPool(mainPool(), a);
231		}
#	Line 234 | Line 235 | public class RecursiveActionTest extends
235		* invoke task throws exception when task completes abnormally
236		*/
237		public void testAbnormalInvoke() {
238	<	RecursiveAction a = new RecursiveAction() {
239	<	public void compute() {
238	>	RecursiveAction a = new CheckedRecursiveAction() {
239	>	public void realCompute() {
240	>	FailingFibAction f = new FailingFibAction(8);
241		try {
240	–	FailingFibAction f = new FailingFibAction(8);
242		f.invoke();
243		shouldThrow();
244	<	} catch (FJException success) {
244	<	}
244	>	} catch (FJException success) {}
245		}};
246		testInvokeOnPool(mainPool(), a);
247		}
#	Line 250 | Line 250 | public class RecursiveActionTest extends
250		* quietlyInvoke task returns when task completes abnormally
251		*/
252		public void testAbnormalQuietlyInvoke() {
253	<	RecursiveAction a = new RecursiveAction() {
254	<	public void compute() {
253	>	RecursiveAction a = new CheckedRecursiveAction() {
254	>	public void realCompute() {
255		FailingFibAction f = new FailingFibAction(8);
256		f.quietlyInvoke();
257	<	threadAssertTrue(f.isDone());
257	>	assertTrue(f.isDone());
258		}};
259		testInvokeOnPool(mainPool(), a);
260		}
#	Line 263 | Line 263 | public class RecursiveActionTest extends
263		* join of a forked task throws exception when task completes abnormally
264		*/
265		public void testAbnormalForkJoin() {
266	<	RecursiveAction a = new RecursiveAction() {
267	<	public void compute() {
266	>	RecursiveAction a = new CheckedRecursiveAction() {
267	>	public void realCompute() {
268	>	FailingFibAction f = new FailingFibAction(8);
269	>	assertSame(f, f.fork());
270		try {
269	–	FailingFibAction f = new FailingFibAction(8);
270	–	threadAssertSame(f, f.fork());
271		f.join();
272		shouldThrow();
273	<	} catch (FJException success) {
274	<	}
273	>	} catch (FJException success) {}
274		}};
275		testInvokeOnPool(mainPool(), a);
276		}
#	Line 280 | Line 279 | public class RecursiveActionTest extends
279		* get of a forked task throws exception when task completes abnormally
280		*/
281		public void testAbnormalForkGet() {
282	<	RecursiveAction a = new RecursiveAction() {
283	<	public void compute() {
282	>	RecursiveAction a = new CheckedRecursiveAction() {
283	>	public void realCompute() throws Exception {
284	>	FailingFibAction f = new FailingFibAction(8);
285	>	assertSame(f, f.fork());
286		try {
286	–	FailingFibAction f = new FailingFibAction(8);
287	–	threadAssertSame(f, f.fork());
287		f.get();
288		shouldThrow();
289	<	} catch (ExecutionException success) {
291	<	} catch (Exception ex) {
292	<	unexpectedException(ex);
293	<	}
289	>	} catch (ExecutionException success) {}
290		}};
291		testInvokeOnPool(mainPool(), a);
292		}
#	Line 299 | Line 295 | public class RecursiveActionTest extends
295		* timed get of a forked task throws exception when task completes abnormally
296		*/
297		public void testAbnormalForkTimedGet() {
298	<	RecursiveAction a = new RecursiveAction() {
299	<	public void compute() {
298	>	RecursiveAction a = new CheckedRecursiveAction() {
299	>	public void realCompute() throws Exception {
300	>	FailingFibAction f = new FailingFibAction(8);
301	>	assertSame(f, f.fork());
302		try {
305	–	FailingFibAction f = new FailingFibAction(8);
306	–	threadAssertSame(f, f.fork());
303		f.get(5L, TimeUnit.SECONDS);
304		shouldThrow();
305	<	} catch (ExecutionException success) {
310	<	} catch (Exception ex) {
311	<	unexpectedException(ex);
312	<	}
305	>	} catch (ExecutionException success) {}
306		}};
307		testInvokeOnPool(mainPool(), a);
308		}
#	Line 318 | Line 311 | public class RecursiveActionTest extends
311		* quietlyJoin of a forked task returns when task completes abnormally
312		*/
313		public void testAbnormalForkQuietlyJoin() {
314	<	RecursiveAction a = new RecursiveAction() {
315	<	public void compute() {
314	>	RecursiveAction a = new CheckedRecursiveAction() {
315	>	public void realCompute() {
316		FailingFibAction f = new FailingFibAction(8);
317	<	threadAssertSame(f, f.fork());
317	>	assertSame(f, f.fork());
318		f.quietlyJoin();
319	<	threadAssertTrue(f.isDone());
320	<	threadAssertTrue(f.isCompletedAbnormally());
321	<	threadAssertTrue(f.getException() instanceof FJException);
319	>	assertTrue(f.isDone());
320	>	assertTrue(f.isCompletedAbnormally());
321	>	assertTrue(f.getException() instanceof FJException);
322		}};
323		testInvokeOnPool(mainPool(), a);
324		}
#	Line 334 | Line 327 | public class RecursiveActionTest extends
327		* invoke task throws exception when task cancelled
328		*/
329		public void testCancelledInvoke() {
330	<	RecursiveAction a = new RecursiveAction() {
331	<	public void compute() {
330	>	RecursiveAction a = new CheckedRecursiveAction() {
331	>	public void realCompute() {
332	>	FibAction f = new FibAction(8);
333	>	assertTrue(f.cancel(true));
334		try {
340	–	FibAction f = new FibAction(8);
341	–	threadAssertTrue(f.cancel(true));
335		f.invoke();
336		shouldThrow();
337	<	} catch (CancellationException success) {
345	<	}
337	>	} catch (CancellationException success) {}
338		}};
339		testInvokeOnPool(mainPool(), a);
340		}
#	Line 351 | Line 343 | public class RecursiveActionTest extends
343		* join of a forked task throws exception when task cancelled
344		*/
345		public void testCancelledForkJoin() {
346	<	RecursiveAction a = new RecursiveAction() {
347	<	public void compute() {
346	>	RecursiveAction a = new CheckedRecursiveAction() {
347	>	public void realCompute() {
348	>	FibAction f = new FibAction(8);
349	>	assertTrue(f.cancel(true));
350	>	assertSame(f, f.fork());
351		try {
357	–	FibAction f = new FibAction(8);
358	–	threadAssertTrue(f.cancel(true));
359	–	threadAssertSame(f, f.fork());
352		f.join();
353		shouldThrow();
354	<	} catch (CancellationException success) {
363	<	}
354	>	} catch (CancellationException success) {}
355		}};
356		testInvokeOnPool(mainPool(), a);
357		}
#	Line 369 | Line 360 | public class RecursiveActionTest extends
360		* get of a forked task throws exception when task cancelled
361		*/
362		public void testCancelledForkGet() {
363	<	RecursiveAction a = new RecursiveAction() {
364	<	public void compute() {
363	>	RecursiveAction a = new CheckedRecursiveAction() {
364	>	public void realCompute() throws Exception {
365	>	FibAction f = new FibAction(8);
366	>	assertTrue(f.cancel(true));
367	>	assertSame(f, f.fork());
368		try {
375	–	FibAction f = new FibAction(8);
376	–	threadAssertTrue(f.cancel(true));
377	–	threadAssertSame(f, f.fork());
369		f.get();
370		shouldThrow();
371	<	} catch (CancellationException success) {
381	<	} catch (Exception ex) {
382	<	unexpectedException(ex);
383	<	}
371	>	} catch (CancellationException success) {}
372		}};
373		testInvokeOnPool(mainPool(), a);
374		}
#	Line 389 | Line 377 | public class RecursiveActionTest extends
377		* timed get of a forked task throws exception when task cancelled
378		*/
379		public void testCancelledForkTimedGet() {
380	<	RecursiveAction a = new RecursiveAction() {
381	<	public void compute() {
380	>	RecursiveAction a = new CheckedRecursiveAction() {
381	>	public void realCompute() throws Exception {
382	>	FibAction f = new FibAction(8);
383	>	assertTrue(f.cancel(true));
384	>	assertSame(f, f.fork());
385		try {
395	–	FibAction f = new FibAction(8);
396	–	threadAssertTrue(f.cancel(true));
397	–	threadAssertSame(f, f.fork());
386		f.get(5L, TimeUnit.SECONDS);
387		shouldThrow();
388	<	} catch (CancellationException success) {
401	<	} catch (Exception ex) {
402	<	unexpectedException(ex);
403	<	}
388	>	} catch (CancellationException success) {}
389		}};
390		testInvokeOnPool(mainPool(), a);
391		}
#	Line 409 | Line 394 | public class RecursiveActionTest extends
394		* quietlyJoin of a forked task returns when task cancelled
395		*/
396		public void testCancelledForkQuietlyJoin() {
397	<	RecursiveAction a = new RecursiveAction() {
398	<	public void compute() {
397	>	RecursiveAction a = new CheckedRecursiveAction() {
398	>	public void realCompute() {
399		FibAction f = new FibAction(8);
400	<	threadAssertTrue(f.cancel(true));
401	<	threadAssertSame(f, f.fork());
400	>	assertTrue(f.cancel(true));
401	>	assertSame(f, f.fork());
402		f.quietlyJoin();
403	<	threadAssertTrue(f.isDone());
404	<	threadAssertTrue(f.isCompletedAbnormally());
405	<	threadAssertTrue(f.getException() instanceof CancellationException);
403	>	assertTrue(f.isDone());
404	>	assertTrue(f.isCompletedAbnormally());
405	>	assertTrue(f.isCancelled());
406	>	assertTrue(f.getException() instanceof CancellationException);
407		}};
408		testInvokeOnPool(mainPool(), a);
409		}
#	Line 427 | Line 413 | public class RecursiveActionTest extends
413		*/
414		public void testGetPool() {
415		final ForkJoinPool mainPool = mainPool();
416	<	RecursiveAction a = new RecursiveAction() {
417	<	final ForkJoinPool p = mainPool;
418	<	public void compute() {
433	<	threadAssertTrue(getPool() == p);
416	>	RecursiveAction a = new CheckedRecursiveAction() {
417	>	public void realCompute() {
418	>	assertSame(mainPool, getPool());
419		}};
420		testInvokeOnPool(mainPool, a);
421		}
#	Line 439 | Line 424 | public class RecursiveActionTest extends
424		* getPool of non-FJ task returns null
425		*/
426		public void testGetPool2() {
427	<	RecursiveAction a = new RecursiveAction() {
428	<	public void compute() {
429	<	threadAssertTrue(getPool() == null);
427	>	RecursiveAction a = new CheckedRecursiveAction() {
428	>	public void realCompute() {
429	>	assertNull(getPool());
430		}};
431		assertNull(a.invoke());
432		}
#	Line 450 | Line 435 | public class RecursiveActionTest extends
435		* inForkJoinPool of executing task returns true
436		*/
437		public void testInForkJoinPool() {
438	<	RecursiveAction a = new RecursiveAction() {
439	<	public void compute() {
440	<	threadAssertTrue(inForkJoinPool());
438	>	RecursiveAction a = new CheckedRecursiveAction() {
439	>	public void realCompute() {
440	>	assertTrue(inForkJoinPool());
441		}};
442		testInvokeOnPool(mainPool(), a);
443		}
#	Line 461 | Line 446 | public class RecursiveActionTest extends
446		* inForkJoinPool of non-FJ task returns false
447		*/
448		public void testInForkJoinPool2() {
449	<	RecursiveAction a = new RecursiveAction() {
450	<	public void compute() {
451	<	threadAssertTrue(!inForkJoinPool());
449	>	RecursiveAction a = new CheckedRecursiveAction() {
450	>	public void realCompute() {
451	>	assertFalse(inForkJoinPool());
452		}};
453		assertNull(a.invoke());
454		}
#	Line 473 | Line 458 | public class RecursiveActionTest extends
458		*/
459		public void testWorkerGetPool() {
460		final ForkJoinPool mainPool = mainPool();
461	<	RecursiveAction a = new RecursiveAction() {
462	<	public void compute() {
461	>	RecursiveAction a = new CheckedRecursiveAction() {
462	>	public void realCompute() {
463		ForkJoinWorkerThread w =
464		(ForkJoinWorkerThread) Thread.currentThread();
465	<	threadAssertTrue(w.getPool() == mainPool);
465	>	assertSame(mainPool, w.getPool());
466		}};
467		testInvokeOnPool(mainPool, a);
468		}
#	Line 487 | Line 472 | public class RecursiveActionTest extends
472		*/
473		public void testWorkerGetPoolIndex() {
474		final ForkJoinPool mainPool = mainPool();
475	<	RecursiveAction a = new RecursiveAction() {
476	<	public void compute() {
475	>	RecursiveAction a = new CheckedRecursiveAction() {
476	>	public void realCompute() {
477		ForkJoinWorkerThread w =
478		(ForkJoinWorkerThread)(Thread.currentThread());
479		int idx = w.getPoolIndex();
480	<	threadAssertTrue(idx >= 0);
481	<	threadAssertTrue(idx < mainPool.getPoolSize());
480	>	assertTrue(idx >= 0);
481	>	assertTrue(idx < mainPool.getPoolSize());
482		}};
483		testInvokeOnPool(mainPool, a);
484		}
#	Line 503 | Line 488 | public class RecursiveActionTest extends
488		* setRawResult(null) succeeds
489		*/
490		public void testSetRawResult() {
491	<	RecursiveAction a = new RecursiveAction() {
492	<	public void compute() {
491	>	RecursiveAction a = new CheckedRecursiveAction() {
492	>	public void realCompute() {
493		setRawResult(null);
494		}};
495		assertNull(a.invoke());
#	Line 514 | Line 499 | public class RecursiveActionTest extends
499		* A reinitialized task may be re-invoked
500		*/
501		public void testReinitialize() {
502	<	RecursiveAction a = new RecursiveAction() {
503	<	public void compute() {
502	>	RecursiveAction a = new CheckedRecursiveAction() {
503	>	public void realCompute() {
504		FibAction f = new FibAction(8);
505	<	threadAssertNull(f.invoke());
506	<	threadAssertTrue(f.result == 21);
507	<	threadAssertTrue(f.isDone());
508	<	threadAssertFalse(f.isCancelled());
509	<	threadAssertFalse(f.isCompletedAbnormally());
505	>	assertNull(f.invoke());
506	>	assertEquals(21, f.result);
507	>	assertTrue(f.isDone());
508	>	assertFalse(f.isCancelled());
509	>	assertFalse(f.isCompletedAbnormally());
510		f.reinitialize();
511	<	threadAssertNull(f.invoke());
512	<	threadAssertTrue(f.result == 21);
511	>	assertNull(f.invoke());
512	>	assertEquals(21, f.result);
513		}};
514		testInvokeOnPool(mainPool(), a);
515		}
#	Line 533 | Line 518 | public class RecursiveActionTest extends
518		* invoke task throws exception after invoking completeExceptionally
519		*/
520		public void testCompleteExceptionally() {
521	<	RecursiveAction a = new RecursiveAction() {
522	<	public void compute() {
521	>	RecursiveAction a = new CheckedRecursiveAction() {
522	>	public void realCompute() {
523	>	FibAction f = new FibAction(8);
524	>	f.completeExceptionally(new FJException());
525		try {
539	–	FibAction f = new FibAction(8);
540	–	f.completeExceptionally(new FJException());
526		f.invoke();
527		shouldThrow();
528	<	} catch (FJException success) {
544	<	}
528	>	} catch (FJException success) {}
529		}};
530		testInvokeOnPool(mainPool(), a);
531		}
#	Line 550 | Line 534 | public class RecursiveActionTest extends
534		* invoke task suppresses execution invoking complete
535		*/
536		public void testComplete() {
537	<	RecursiveAction a = new RecursiveAction() {
538	<	public void compute() {
537	>	RecursiveAction a = new CheckedRecursiveAction() {
538	>	public void realCompute() {
539		FibAction f = new FibAction(8);
540		f.complete(null);
541	<	threadAssertNull(f.invoke());
542	<	threadAssertTrue(f.isDone());
543	<	threadAssertTrue(f.result == 0);
541	>	assertNull(f.invoke());
542	>	assertTrue(f.isDone());
543	>	assertEquals(0, f.result);
544		}};
545		testInvokeOnPool(mainPool(), a);
546		}
#	Line 565 | Line 549 | public class RecursiveActionTest extends
549		* invokeAll(t1, t2) invokes all task arguments
550		*/
551		public void testInvokeAll2() {
552	<	RecursiveAction a = new RecursiveAction() {
553	<	public void compute() {
552	>	RecursiveAction a = new CheckedRecursiveAction() {
553	>	public void realCompute() {
554		FibAction f = new FibAction(8);
555		FibAction g = new FibAction(9);
556		invokeAll(f, g);
557	<	threadAssertTrue(f.isDone());
558	<	threadAssertTrue(f.result == 21);
559	<	threadAssertTrue(g.isDone());
560	<	threadAssertTrue(g.result == 34);
557	>	assertTrue(f.isDone());
558	>	assertEquals(21, f.result);
559	>	assertTrue(g.isDone());
560	>	assertEquals(34, g.result);
561		}};
562		testInvokeOnPool(mainPool(), a);
563		}
#	Line 582 | Line 566 | public class RecursiveActionTest extends
566		* invokeAll(tasks) with 1 argument invokes task
567		*/
568		public void testInvokeAll1() {
569	<	RecursiveAction a = new RecursiveAction() {
570	<	public void compute() {
569	>	RecursiveAction a = new CheckedRecursiveAction() {
570	>	public void realCompute() {
571		FibAction f = new FibAction(8);
572		invokeAll(f);
573	<	threadAssertTrue(f.isDone());
574	<	threadAssertTrue(f.result == 21);
573	>	assertTrue(f.isDone());
574	>	assertEquals(21, f.result);
575		}};
576		testInvokeOnPool(mainPool(), a);
577		}
#	Line 596 | Line 580 | public class RecursiveActionTest extends
580		* invokeAll(tasks) with > 2 argument invokes tasks
581		*/
582		public void testInvokeAll3() {
583	<	RecursiveAction a = new RecursiveAction() {
584	<	public void compute() {
583	>	RecursiveAction a = new CheckedRecursiveAction() {
584	>	public void realCompute() {
585		FibAction f = new FibAction(8);
586		FibAction g = new FibAction(9);
587		FibAction h = new FibAction(7);
588		invokeAll(f, g, h);
589	<	threadAssertTrue(f.isDone());
590	<	threadAssertTrue(f.result == 21);
591	<	threadAssertTrue(g.isDone());
592	<	threadAssertTrue(g.result == 34);
593	<	threadAssertTrue(h.isDone());
594	<	threadAssertTrue(h.result == 13);
589	>	assertTrue(f.isDone());
590	>	assertEquals(21, f.result);
591	>	assertTrue(g.isDone());
592	>	assertEquals(34, g.result);
593	>	assertTrue(h.isDone());
594	>	assertEquals(13, h.result);
595		}};
596		testInvokeOnPool(mainPool(), a);
597		}
#	Line 616 | Line 600 | public class RecursiveActionTest extends
600		* invokeAll(collection) invokes all tasks in the collection
601		*/
602		public void testInvokeAllCollection() {
603	<	RecursiveAction a = new RecursiveAction() {
604	<	public void compute() {
603	>	RecursiveAction a = new CheckedRecursiveAction() {
604	>	public void realCompute() {
605		FibAction f = new FibAction(8);
606		FibAction g = new FibAction(9);
607		FibAction h = new FibAction(7);
#	Line 626 | Line 610 | public class RecursiveActionTest extends
610		set.add(g);
611		set.add(h);
612		invokeAll(set);
613	<	threadAssertTrue(f.isDone());
614	<	threadAssertTrue(f.result == 21);
615	<	threadAssertTrue(g.isDone());
616	<	threadAssertTrue(g.result == 34);
617	<	threadAssertTrue(h.isDone());
618	<	threadAssertTrue(h.result == 13);
613	>	assertTrue(f.isDone());
614	>	assertEquals(21, f.result);
615	>	assertTrue(g.isDone());
616	>	assertEquals(34, g.result);
617	>	assertTrue(h.isDone());
618	>	assertEquals(13, h.result);
619		}};
620		testInvokeOnPool(mainPool(), a);
621		}
#	Line 641 | Line 625 | public class RecursiveActionTest extends
625		* invokeAll(tasks) with any null task throws NPE
626		*/
627		public void testInvokeAllNPE() {
628	<	RecursiveAction a = new RecursiveAction() {
629	<	public void compute() {
628	>	RecursiveAction a = new CheckedRecursiveAction() {
629	>	public void realCompute() {
630	>	FibAction f = new FibAction(8);
631	>	FibAction g = new FibAction(9);
632	>	FibAction h = null;
633		try {
647	–	FibAction f = new FibAction(8);
648	–	FibAction g = new FibAction(9);
649	–	FibAction h = null;
634		invokeAll(f, g, h);
635		shouldThrow();
636	<	} catch (NullPointerException success) {
653	<	}
636	>	} catch (NullPointerException success) {}
637		}};
638		testInvokeOnPool(mainPool(), a);
639		}
#	Line 659 | Line 642 | public class RecursiveActionTest extends
642		* invokeAll(t1, t2) throw exception if any task does
643		*/
644		public void testAbnormalInvokeAll2() {
645	<	RecursiveAction a = new RecursiveAction() {
646	<	public void compute() {
645	>	RecursiveAction a = new CheckedRecursiveAction() {
646	>	public void realCompute() {
647	>	FibAction f = new FibAction(8);
648	>	FailingFibAction g = new FailingFibAction(9);
649		try {
665	–	FibAction f = new FibAction(8);
666	–	FailingFibAction g = new FailingFibAction(9);
650		invokeAll(f, g);
651		shouldThrow();
652	<	} catch (FJException success) {
670	<	}
652	>	} catch (FJException success) {}
653		}};
654		testInvokeOnPool(mainPool(), a);
655		}
#	Line 676 | Line 658 | public class RecursiveActionTest extends
658		* invokeAll(tasks) with 1 argument throws exception if task does
659		*/
660		public void testAbnormalInvokeAll1() {
661	<	RecursiveAction a = new RecursiveAction() {
662	<	public void compute() {
661	>	RecursiveAction a = new CheckedRecursiveAction() {
662	>	public void realCompute() {
663	>	FailingFibAction g = new FailingFibAction(9);
664		try {
682	–	FailingFibAction g = new FailingFibAction(9);
665		invokeAll(g);
666		shouldThrow();
667	<	} catch (FJException success) {
686	<	}
667	>	} catch (FJException success) {}
668		}};
669		testInvokeOnPool(mainPool(), a);
670		}
#	Line 692 | Line 673 | public class RecursiveActionTest extends
673		* invokeAll(tasks) with > 2 argument throws exception if any task does
674		*/
675		public void testAbnormalInvokeAll3() {
676	<	RecursiveAction a = new RecursiveAction() {
677	<	public void compute() {
676	>	RecursiveAction a = new CheckedRecursiveAction() {
677	>	public void realCompute() {
678	>	FibAction f = new FibAction(8);
679	>	FailingFibAction g = new FailingFibAction(9);
680	>	FibAction h = new FibAction(7);
681		try {
698	–	FibAction f = new FibAction(8);
699	–	FailingFibAction g = new FailingFibAction(9);
700	–	FibAction h = new FibAction(7);
682		invokeAll(f, g, h);
683		shouldThrow();
684	<	} catch (FJException success) {
704	<	}
684	>	} catch (FJException success) {}
685		}};
686		testInvokeOnPool(mainPool(), a);
687		}
#	Line 710 | Line 690 | public class RecursiveActionTest extends
690		* invokeAll(collection) throws exception if any task does
691		*/
692		public void testAbnormalInvokeAllCollection() {
693	<	RecursiveAction a = new RecursiveAction() {
694	<	public void compute() {
693	>	RecursiveAction a = new CheckedRecursiveAction() {
694	>	public void realCompute() {
695	>	FailingFibAction f = new FailingFibAction(8);
696	>	FibAction g = new FibAction(9);
697	>	FibAction h = new FibAction(7);
698	>	HashSet set = new HashSet();
699	>	set.add(f);
700	>	set.add(g);
701	>	set.add(h);
702		try {
716	–	FailingFibAction f = new FailingFibAction(8);
717	–	FibAction g = new FibAction(9);
718	–	FibAction h = new FibAction(7);
719	–	HashSet set = new HashSet();
720	–	set.add(f);
721	–	set.add(g);
722	–	set.add(h);
703		invokeAll(set);
704		shouldThrow();
705	<	} catch (FJException success) {
726	<	}
705	>	} catch (FJException success) {}
706		}};
707		testInvokeOnPool(mainPool(), a);
708		}
#	Line 733 | Line 712 | public class RecursiveActionTest extends
712		* and suppresses execution
713		*/
714		public void testTryUnfork() {
715	<	RecursiveAction a = new RecursiveAction() {
716	<	public void compute() {
715	>	RecursiveAction a = new CheckedRecursiveAction() {
716	>	public void realCompute() {
717		FibAction g = new FibAction(9);
718	<	threadAssertSame(g, g.fork());
718	>	assertSame(g, g.fork());
719		FibAction f = new FibAction(8);
720	<	threadAssertSame(f, f.fork());
721	<	threadAssertTrue(f.tryUnfork());
720	>	assertSame(f, f.fork());
721	>	assertTrue(f.tryUnfork());
722		helpQuiesce();
723	<	threadAssertFalse(f.isDone());
724	<	threadAssertTrue(g.isDone());
723	>	assertFalse(f.isDone());
724	>	assertTrue(g.isDone());
725		}};
726		testInvokeOnPool(singletonPool(), a);
727		}
#	Line 752 | Line 731 | public class RecursiveActionTest extends
731		* there are more tasks than threads
732		*/
733		public void testGetSurplusQueuedTaskCount() {
734	<	RecursiveAction a = new RecursiveAction() {
735	<	public void compute() {
734	>	RecursiveAction a = new CheckedRecursiveAction() {
735	>	public void realCompute() {
736		FibAction h = new FibAction(7);
737	<	threadAssertSame(h, h.fork());
737	>	assertSame(h, h.fork());
738		FibAction g = new FibAction(9);
739	<	threadAssertSame(g, g.fork());
739	>	assertSame(g, g.fork());
740		FibAction f = new FibAction(8);
741	<	threadAssertSame(f, f.fork());
742	<	threadAssertTrue(getSurplusQueuedTaskCount() > 0);
741	>	assertSame(f, f.fork());
742	>	assertTrue(getSurplusQueuedTaskCount() > 0);
743		helpQuiesce();
744		}};
745		testInvokeOnPool(singletonPool(), a);
#	Line 770 | Line 749 | public class RecursiveActionTest extends
749		* peekNextLocalTask returns most recent unexecuted task.
750		*/
751		public void testPeekNextLocalTask() {
752	<	RecursiveAction a = new RecursiveAction() {
753	<	public void compute() {
752	>	RecursiveAction a = new CheckedRecursiveAction() {
753	>	public void realCompute() {
754		FibAction g = new FibAction(9);
755	<	threadAssertSame(g, g.fork());
755	>	assertSame(g, g.fork());
756		FibAction f = new FibAction(8);
757	<	threadAssertSame(f, f.fork());
758	<	threadAssertTrue(peekNextLocalTask() == f);
759	<	threadAssertNull(f.join());
760	<	threadAssertTrue(f.isDone());
757	>	assertSame(f, f.fork());
758	>	assertSame(f, peekNextLocalTask());
759	>	assertNull(f.join());
760	>	assertTrue(f.isDone());
761		helpQuiesce();
762		}};
763		testInvokeOnPool(singletonPool(), a);
#	Line 789 | Line 768 | public class RecursiveActionTest extends
768		* without executing it
769		*/
770		public void testPollNextLocalTask() {
771	<	RecursiveAction a = new RecursiveAction() {
772	<	public void compute() {
771	>	RecursiveAction a = new CheckedRecursiveAction() {
772	>	public void realCompute() {
773		FibAction g = new FibAction(9);
774	<	threadAssertSame(g, g.fork());
774	>	assertSame(g, g.fork());
775		FibAction f = new FibAction(8);
776	<	threadAssertSame(f, f.fork());
777	<	threadAssertTrue(pollNextLocalTask() == f);
776	>	assertSame(f, f.fork());
777	>	assertSame(f, pollNextLocalTask());
778		helpQuiesce();
779	<	threadAssertFalse(f.isDone());
779	>	assertFalse(f.isDone());
780		}};
781		testInvokeOnPool(singletonPool(), a);
782		}
#	Line 807 | Line 786 | public class RecursiveActionTest extends
786		* without executing it
787		*/
788		public void testPollTask() {
789	<	RecursiveAction a = new RecursiveAction() {
790	<	public void compute() {
789	>	RecursiveAction a = new CheckedRecursiveAction() {
790	>	public void realCompute() {
791		FibAction g = new FibAction(9);
792	<	threadAssertSame(g, g.fork());
792	>	assertSame(g, g.fork());
793		FibAction f = new FibAction(8);
794	<	threadAssertSame(f, f.fork());
795	<	threadAssertTrue(pollTask() == f);
794	>	assertSame(f, f.fork());
795	>	assertSame(f, pollTask());
796		helpQuiesce();
797	<	threadAssertFalse(f.isDone());
798	<	threadAssertTrue(g.isDone());
797	>	assertFalse(f.isDone());
798	>	assertTrue(g.isDone());
799		}};
800		testInvokeOnPool(singletonPool(), a);
801		}
#	Line 825 | Line 804 | public class RecursiveActionTest extends
804		* peekNextLocalTask returns least recent unexecuted task in async mode
805		*/
806		public void testPeekNextLocalTaskAsync() {
807	<	RecursiveAction a = new RecursiveAction() {
808	<	public void compute() {
807	>	RecursiveAction a = new CheckedRecursiveAction() {
808	>	public void realCompute() {
809		FibAction g = new FibAction(9);
810	<	threadAssertSame(g, g.fork());
810	>	assertSame(g, g.fork());
811		FibAction f = new FibAction(8);
812	<	threadAssertSame(f, f.fork());
813	<	threadAssertTrue(peekNextLocalTask() == g);
814	<	threadAssertNull(f.join());
812	>	assertSame(f, f.fork());
813	>	assertSame(g, peekNextLocalTask());
814	>	assertNull(f.join());
815		helpQuiesce();
816	<	threadAssertTrue(f.isDone());
816	>	assertTrue(f.isDone());
817		}};
818		testInvokeOnPool(asyncSingletonPool(), a);
819		}
#	Line 844 | Line 823 | public class RecursiveActionTest extends
823		* without executing it, in async mode
824		*/
825		public void testPollNextLocalTaskAsync() {
826	<	RecursiveAction a = new RecursiveAction() {
827	<	public void compute() {
826	>	RecursiveAction a = new CheckedRecursiveAction() {
827	>	public void realCompute() {
828		FibAction g = new FibAction(9);
829	<	threadAssertSame(g, g.fork());
829	>	assertSame(g, g.fork());
830		FibAction f = new FibAction(8);
831	<	threadAssertSame(f, f.fork());
832	<	threadAssertTrue(pollNextLocalTask() == g);
831	>	assertSame(f, f.fork());
832	>	assertSame(g, pollNextLocalTask());
833		helpQuiesce();
834	<	threadAssertTrue(f.isDone());
835	<	threadAssertFalse(g.isDone());
834	>	assertTrue(f.isDone());
835	>	assertFalse(g.isDone());
836		}};
837		testInvokeOnPool(asyncSingletonPool(), a);
838		}
#	Line 863 | Line 842 | public class RecursiveActionTest extends
842		* without executing it, in async mode
843		*/
844		public void testPollTaskAsync() {
845	<	RecursiveAction a = new RecursiveAction() {
846	<	public void compute() {
845	>	RecursiveAction a = new CheckedRecursiveAction() {
846	>	public void realCompute() {
847		FibAction g = new FibAction(9);
848	<	threadAssertSame(g, g.fork());
848	>	assertSame(g, g.fork());
849		FibAction f = new FibAction(8);
850	<	threadAssertSame(f, f.fork());
851	<	threadAssertTrue(pollTask() == g);
850	>	assertSame(f, f.fork());
851	>	assertSame(g, pollTask());
852		helpQuiesce();
853	<	threadAssertTrue(f.isDone());
854	<	threadAssertFalse(g.isDone());
853	>	assertTrue(f.isDone());
854	>	assertFalse(g.isDone());
855		}};
856		testInvokeOnPool(asyncSingletonPool(), a);
857		}

Diff Legend

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