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.7 by jsr166, Wed Aug 5 01:17:30 2009 UTC vs.
Revision 1.17 by dl, Wed Sep 15 12:46:57 2010 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/licenses/publicdomain
5		*/
6	–	import junit.framework.*;
7	–	import java.util.concurrent.*;
8	–	import java.util.*;
6
7	+	import junit.framework.*;
8	+	import java.util.concurrent.CancellationException;
9	+	import java.util.concurrent.ExecutionException;
10	+	import java.util.concurrent.ForkJoinPool;
11	+	import java.util.concurrent.ForkJoinWorkerThread;
12	+	import java.util.concurrent.RecursiveAction;
13	+	import java.util.concurrent.TimeUnit;
14	+	import java.util.HashSet;
15
16		public class RecursiveActionTest extends JSR166TestCase {
17
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run (suite());
19	>	junit.textui.TestRunner.run(suite());
20		}
21	+
22		public static Test suite() {
23	<	return new TestSuite(RecursiveActionTest.class);
23	>	return new TestSuite(RecursiveActionTest.class);
24	>	}
25	>
26	>	private static ForkJoinPool mainPool() {
27	>	return new ForkJoinPool();
28	>	}
29	>
30	>	private static ForkJoinPool singletonPool() {
31	>	return new ForkJoinPool(1);
32	>	}
33	>
34	>	private static ForkJoinPool asyncSingletonPool() {
35	>	return new ForkJoinPool(1,
36	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
37	>	null, true);
38		}
39
40	<	static final ForkJoinPool mainPool = new ForkJoinPool();
41	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
42	<	static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
43	<	static {
44	<	asyncSingletonPool.setAsyncMode(true);
40	>	private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
41	>	try {
42	>	assertTrue(pool.invoke(a) == null);
43	>	} finally {
44	>	joinPool(pool);
45	>	}
46		}
47
48		static final class FJException extends RuntimeException {
#	Line 68 | Line 89 | public class RecursiveActionTest extends
89		* invoke returns when task completes normally.
90		* isCompletedAbnormally and isCancelled return false for normally
91		* completed tasks. getRawResult of a RecursiveAction returns null;
71	–	*
92		*/
93		public void testInvoke() {
94		RecursiveAction a = new RecursiveAction() {
95		public void compute() {
96		FibAction f = new FibAction(8);
97	<	f.invoke();
97	>	threadAssertNull(f.invoke());
98		threadAssertTrue(f.result == 21);
99		threadAssertTrue(f.isDone());
100		threadAssertFalse(f.isCancelled());
101		threadAssertFalse(f.isCompletedAbnormally());
102		threadAssertTrue(f.getRawResult() == null);
103		}};
104	<	mainPool.invoke(a);
104	>	testInvokeOnPool(mainPool(), a);
105		}
106
107		/**
#	Line 100 | Line 120 | public class RecursiveActionTest extends
120		threadAssertFalse(f.isCompletedAbnormally());
121		threadAssertTrue(f.getRawResult() == null);
122		}};
123	<	mainPool.invoke(a);
123	>	testInvokeOnPool(mainPool(), a);
124		}
125
126		/**
#	Line 110 | Line 130 | public class RecursiveActionTest extends
130		RecursiveAction a = new RecursiveAction() {
131		public void compute() {
132		FibAction f = new FibAction(8);
133	<	f.fork();
134	<	f.join();
133	>	threadAssertSame(f, f.fork());
134	>	threadAssertNull(f.join());
135		threadAssertTrue(f.result == 21);
136		threadAssertTrue(f.isDone());
137		threadAssertTrue(f.getRawResult() == null);
138		}};
139	<	mainPool.invoke(a);
139	>	testInvokeOnPool(mainPool(), a);
140		}
141
142		/**
#	Line 127 | Line 147 | public class RecursiveActionTest extends
147		public void compute() {
148		try {
149		FibAction f = new FibAction(8);
150	<	f.fork();
151	<	f.get();
150	>	threadAssertSame(f, f.fork());
151	>	threadAssertNull(f.get());
152		threadAssertTrue(f.result == 21);
153		threadAssertTrue(f.isDone());
154		} catch (Exception ex) {
155		unexpectedException(ex);
156		}
157		}};
158	<	mainPool.invoke(a);
158	>	testInvokeOnPool(mainPool(), a);
159		}
160
161		/**
#	Line 146 | Line 166 | public class RecursiveActionTest extends
166		public void compute() {
167		try {
168		FibAction f = new FibAction(8);
169	<	f.fork();
170	<	f.get(5L, TimeUnit.SECONDS);
169	>	threadAssertSame(f, f.fork());
170	>	threadAssertNull(f.get(5L, TimeUnit.SECONDS));
171		threadAssertTrue(f.result == 21);
172		threadAssertTrue(f.isDone());
173		} catch (Exception ex) {
174		unexpectedException(ex);
175		}
176		}};
177	<	mainPool.invoke(a);
177	>	testInvokeOnPool(mainPool(), a);
178		}
179
180		/**
#	Line 162 | Line 182 | public class RecursiveActionTest extends
182		*/
183		public void testForkTimedGetNPE() {
184		RecursiveAction a = new RecursiveAction() {
165	–	public void compute() {
166	–	try {
167	–	FibAction f = new FibAction(8);
168	–	f.fork();
169	–	f.get(5L, null);
170	–	shouldThrow();
171	–	} catch (NullPointerException success) {
172	–	} catch (Exception ex) {
173	–	unexpectedException(ex);
174	–	}
175	–	}
176	–	};
177	–	mainPool.invoke(a);
178	–	}
179	–
180	–	/**
181	–	* helpJoin of a forked task returns when task completes
182	–	*/
183	–	public void testForkHelpJoin() {
184	–	RecursiveAction a = new RecursiveAction() {
185		public void compute() {
186	<	FibAction f = new FibAction(8);
187	<	f.fork();
188	<	f.helpJoin();
189	<	threadAssertTrue(f.result == 21);
190	<	threadAssertTrue(f.isDone());
186	>	try {
187	>	FibAction f = new FibAction(8);
188	>	threadAssertSame(f, f.fork());
189	>	f.get(5L, null);
190	>	shouldThrow();
191	>	} catch (NullPointerException success) {
192	>	} catch (Exception ex) {
193	>	unexpectedException(ex);
194	>	}
195		}};
196	<	mainPool.invoke(a);
196	>	testInvokeOnPool(mainPool(), a);
197		}
198
199		/**
#	Line 199 | Line 203 | public class RecursiveActionTest extends
203		RecursiveAction a = new RecursiveAction() {
204		public void compute() {
205		FibAction f = new FibAction(8);
206	<	f.fork();
206	>	threadAssertSame(f, f.fork());
207		f.quietlyJoin();
208		threadAssertTrue(f.result == 21);
209		threadAssertTrue(f.isDone());
210		}};
211	<	mainPool.invoke(a);
208	<	}
209	<
210	<
211	<	/**
212	<	* quietlyHelpJoin of a forked task returns when task completes
213	<	*/
214	<	public void testForkQuietlyHelpJoin() {
215	<	RecursiveAction a = new RecursiveAction() {
216	<	public void compute() {
217	<	FibAction f = new FibAction(8);
218	<	f.fork();
219	<	f.quietlyHelpJoin();
220	<	threadAssertTrue(f.result == 21);
221	<	threadAssertTrue(f.isDone());
222	<	}};
223	<	mainPool.invoke(a);
211	>	testInvokeOnPool(mainPool(), a);
212		}
213
214
#	Line 232 | Line 220 | public class RecursiveActionTest extends
220		RecursiveAction a = new RecursiveAction() {
221		public void compute() {
222		FibAction f = new FibAction(8);
223	<	f.fork();
223	>	threadAssertSame(f, f.fork());
224		f.helpQuiesce();
225		threadAssertTrue(f.result == 21);
226		threadAssertTrue(f.isDone());
227		threadAssertTrue(getQueuedTaskCount() == 0);
228		}};
229	<	mainPool.invoke(a);
229	>	testInvokeOnPool(mainPool(), a);
230		}
231
232
#	Line 255 | Line 243 | public class RecursiveActionTest extends
243		} catch (FJException success) {
244		}
245		}};
246	<	mainPool.invoke(a);
246	>	testInvokeOnPool(mainPool(), a);
247		}
248
249		/**
#	Line 268 | Line 256 | public class RecursiveActionTest extends
256		f.quietlyInvoke();
257		threadAssertTrue(f.isDone());
258		}};
259	<	mainPool.invoke(a);
259	>	testInvokeOnPool(mainPool(), a);
260		}
261
262		/**
#	Line 279 | Line 267 | public class RecursiveActionTest extends
267		public void compute() {
268		try {
269		FailingFibAction f = new FailingFibAction(8);
270	<	f.fork();
270	>	threadAssertSame(f, f.fork());
271		f.join();
272		shouldThrow();
273		} catch (FJException success) {
274		}
275		}};
276	<	mainPool.invoke(a);
276	>	testInvokeOnPool(mainPool(), a);
277		}
278
279		/**
#	Line 296 | Line 284 | public class RecursiveActionTest extends
284		public void compute() {
285		try {
286		FailingFibAction f = new FailingFibAction(8);
287	<	f.fork();
287	>	threadAssertSame(f, f.fork());
288		f.get();
289		shouldThrow();
290		} catch (ExecutionException success) {
#	Line 304 | Line 292 | public class RecursiveActionTest extends
292		unexpectedException(ex);
293		}
294		}};
295	<	mainPool.invoke(a);
295	>	testInvokeOnPool(mainPool(), a);
296		}
297
298		/**
#	Line 315 | Line 303 | public class RecursiveActionTest extends
303		public void compute() {
304		try {
305		FailingFibAction f = new FailingFibAction(8);
306	<	f.fork();
306	>	threadAssertSame(f, f.fork());
307		f.get(5L, TimeUnit.SECONDS);
308		shouldThrow();
309		} catch (ExecutionException success) {
#	Line 323 | Line 311 | public class RecursiveActionTest extends
311		unexpectedException(ex);
312		}
313		}};
314	<	mainPool.invoke(a);
327	<	}
328	<
329	<	/**
330	<	* join of a forked task throws exception when task completes abnormally
331	<	*/
332	<	public void testAbnormalForkHelpJoin() {
333	<	RecursiveAction a = new RecursiveAction() {
334	<	public void compute() {
335	<	try {
336	<	FailingFibAction f = new FailingFibAction(8);
337	<	f.fork();
338	<	f.helpJoin();
339	<	shouldThrow();
340	<	} catch (FJException success) {
341	<	}
342	<	}};
343	<	mainPool.invoke(a);
344	<	}
345	<
346	<	/**
347	<	* quietlyHelpJoin of a forked task returns when task completes abnormally.
348	<	* getException of failed task returns its exception.
349	<	* isCompletedAbnormally of a failed task returns true.
350	<	* isCancelled of a failed uncancelled task returns false
351	<	*/
352	<	public void testAbnormalForkQuietlyHelpJoin() {
353	<	RecursiveAction a = new RecursiveAction() {
354	<	public void compute() {
355	<	FailingFibAction f = new FailingFibAction(8);
356	<	f.fork();
357	<	f.quietlyHelpJoin();
358	<	threadAssertTrue(f.isDone());
359	<	threadAssertTrue(f.isCompletedAbnormally());
360	<	threadAssertFalse(f.isCancelled());
361	<	threadAssertTrue(f.getException() instanceof FJException);
362	<	}};
363	<	mainPool.invoke(a);
314	>	testInvokeOnPool(mainPool(), a);
315		}
316
317		/**
#	Line 370 | Line 321 | public class RecursiveActionTest extends
321		RecursiveAction a = new RecursiveAction() {
322		public void compute() {
323		FailingFibAction f = new FailingFibAction(8);
324	<	f.fork();
324	>	threadAssertSame(f, f.fork());
325		f.quietlyJoin();
326		threadAssertTrue(f.isDone());
327		threadAssertTrue(f.isCompletedAbnormally());
328		threadAssertTrue(f.getException() instanceof FJException);
329		}};
330	<	mainPool.invoke(a);
330	>	testInvokeOnPool(mainPool(), a);
331		}
332
333		/**
#	Line 387 | Line 338 | public class RecursiveActionTest extends
338		public void compute() {
339		try {
340		FibAction f = new FibAction(8);
341	<	f.cancel(true);
341	>	threadAssertTrue(f.cancel(true));
342		f.invoke();
343		shouldThrow();
344		} catch (CancellationException success) {
345		}
346		}};
347	<	mainPool.invoke(a);
347	>	testInvokeOnPool(mainPool(), a);
348		}
349
350		/**
#	Line 404 | Line 355 | public class RecursiveActionTest extends
355		public void compute() {
356		try {
357		FibAction f = new FibAction(8);
358	<	f.cancel(true);
359	<	f.fork();
358	>	threadAssertTrue(f.cancel(true));
359	>	threadAssertSame(f, f.fork());
360		f.join();
361		shouldThrow();
362		} catch (CancellationException success) {
363		}
364		}};
365	<	mainPool.invoke(a);
365	>	testInvokeOnPool(mainPool(), a);
366		}
367
368		/**
#	Line 422 | Line 373 | public class RecursiveActionTest extends
373		public void compute() {
374		try {
375		FibAction f = new FibAction(8);
376	<	f.cancel(true);
377	<	f.fork();
376	>	threadAssertTrue(f.cancel(true));
377	>	threadAssertSame(f, f.fork());
378		f.get();
379		shouldThrow();
380		} catch (CancellationException success) {
#	Line 431 | Line 382 | public class RecursiveActionTest extends
382		unexpectedException(ex);
383		}
384		}};
385	<	mainPool.invoke(a);
385	>	testInvokeOnPool(mainPool(), a);
386		}
387
388		/**
#	Line 442 | Line 393 | public class RecursiveActionTest extends
393		public void compute() {
394		try {
395		FibAction f = new FibAction(8);
396	<	f.cancel(true);
397	<	f.fork();
396	>	threadAssertTrue(f.cancel(true));
397	>	threadAssertSame(f, f.fork());
398		f.get(5L, TimeUnit.SECONDS);
399		shouldThrow();
400		} catch (CancellationException success) {
#	Line 451 | Line 402 | public class RecursiveActionTest extends
402		unexpectedException(ex);
403		}
404		}};
405	<	mainPool.invoke(a);
455	<	}
456	<
457	<	/**
458	<	* join of a forked task throws exception when task cancelled
459	<	*/
460	<	public void testCancelledForkHelpJoin() {
461	<	RecursiveAction a = new RecursiveAction() {
462	<	public void compute() {
463	<	try {
464	<	FibAction f = new FibAction(8);
465	<	f.cancel(true);
466	<	f.fork();
467	<	f.helpJoin();
468	<	shouldThrow();
469	<	} catch (CancellationException success) {
470	<	}
471	<	}};
472	<	mainPool.invoke(a);
473	<	}
474	<
475	<	/**
476	<	* quietlyHelpJoin of a forked task returns when task cancelled.
477	<	* getException of cancelled task returns its exception.
478	<	* isCompletedAbnormally of a cancelled task returns true.
479	<	* isCancelled of a cancelled task returns true
480	<	*/
481	<	public void testCancelledForkQuietlyHelpJoin() {
482	<	RecursiveAction a = new RecursiveAction() {
483	<	public void compute() {
484	<	FibAction f = new FibAction(8);
485	<	f.cancel(true);
486	<	f.fork();
487	<	f.quietlyHelpJoin();
488	<	threadAssertTrue(f.isDone());
489	<	threadAssertTrue(f.isCompletedAbnormally());
490	<	threadAssertTrue(f.isCancelled());
491	<	threadAssertTrue(f.getException() instanceof CancellationException);
492	<	}};
493	<	mainPool.invoke(a);
405	>	testInvokeOnPool(mainPool(), a);
406		}
407
408		/**
#	Line 500 | Line 412 | public class RecursiveActionTest extends
412		RecursiveAction a = new RecursiveAction() {
413		public void compute() {
414		FibAction f = new FibAction(8);
415	<	f.cancel(true);
416	<	f.fork();
415	>	threadAssertTrue(f.cancel(true));
416	>	threadAssertSame(f, f.fork());
417		f.quietlyJoin();
418		threadAssertTrue(f.isDone());
419		threadAssertTrue(f.isCompletedAbnormally());
420		threadAssertTrue(f.getException() instanceof CancellationException);
421		}};
422	<	mainPool.invoke(a);
422	>	testInvokeOnPool(mainPool(), a);
423		}
424
425		/**
426		* getPool of executing task returns its pool
427		*/
428		public void testGetPool() {
429	+	final ForkJoinPool mainPool = mainPool();
430		RecursiveAction a = new RecursiveAction() {
431	+	final ForkJoinPool p = mainPool;
432		public void compute() {
433	<	threadAssertTrue(getPool() == mainPool);
433	>	threadAssertTrue(getPool() == p);
434		}};
435	<	mainPool.invoke(a);
435	>	testInvokeOnPool(mainPool, a);
436		}
437
438		/**
#	Line 529 | Line 443 | public class RecursiveActionTest extends
443		public void compute() {
444		threadAssertTrue(getPool() == null);
445		}};
446	<	a.invoke();
446	>	assertNull(a.invoke());
447		}
448
449		/**
#	Line 540 | Line 454 | public class RecursiveActionTest extends
454		public void compute() {
455		threadAssertTrue(inForkJoinPool());
456		}};
457	<	mainPool.invoke(a);
457	>	testInvokeOnPool(mainPool(), a);
458		}
459
460		/**
#	Line 551 | Line 465 | public class RecursiveActionTest extends
465		public void compute() {
466		threadAssertTrue(!inForkJoinPool());
467		}};
468	<	a.invoke();
468	>	assertNull(a.invoke());
469		}
470
471		/**
472		* getPool of current thread in pool returns its pool
473		*/
474		public void testWorkerGetPool() {
475	+	final ForkJoinPool mainPool = mainPool();
476		RecursiveAction a = new RecursiveAction() {
477		public void compute() {
478		ForkJoinWorkerThread w =
479	<	(ForkJoinWorkerThread)(Thread.currentThread());
479	>	(ForkJoinWorkerThread) Thread.currentThread();
480		threadAssertTrue(w.getPool() == mainPool);
481		}};
482	<	mainPool.invoke(a);
482	>	testInvokeOnPool(mainPool, a);
483		}
484
485		/**
486		* getPoolIndex of current thread in pool returns 0 <= value < poolSize
572	–	*
487		*/
488		public void testWorkerGetPoolIndex() {
489	+	final ForkJoinPool mainPool = mainPool();
490		RecursiveAction a = new RecursiveAction() {
491		public void compute() {
492		ForkJoinWorkerThread w =
#	Line 580 | Line 495 | public class RecursiveActionTest extends
495		threadAssertTrue(idx >= 0);
496		threadAssertTrue(idx < mainPool.getPoolSize());
497		}};
498	<	mainPool.invoke(a);
498	>	testInvokeOnPool(mainPool, a);
499		}
500
501
#	Line 592 | Line 507 | public class RecursiveActionTest extends
507		public void compute() {
508		setRawResult(null);
509		}};
510	<	a.invoke();
510	>	assertNull(a.invoke());
511		}
512
513		/**
#	Line 602 | Line 517 | public class RecursiveActionTest extends
517		RecursiveAction a = new RecursiveAction() {
518		public void compute() {
519		FibAction f = new FibAction(8);
520	<	f.invoke();
520	>	threadAssertNull(f.invoke());
521		threadAssertTrue(f.result == 21);
522		threadAssertTrue(f.isDone());
523		threadAssertFalse(f.isCancelled());
524		threadAssertFalse(f.isCompletedAbnormally());
525		f.reinitialize();
526	<	f.invoke();
526	>	threadAssertNull(f.invoke());
527		threadAssertTrue(f.result == 21);
528		}};
529	<	mainPool.invoke(a);
529	>	testInvokeOnPool(mainPool(), a);
530		}
531
532		/**
#	Line 628 | Line 543 | public class RecursiveActionTest extends
543		} catch (FJException success) {
544		}
545		}};
546	<	mainPool.invoke(a);
546	>	testInvokeOnPool(mainPool(), a);
547		}
548
549		/**
#	Line 639 | Line 554 | public class RecursiveActionTest extends
554		public void compute() {
555		FibAction f = new FibAction(8);
556		f.complete(null);
557	<	f.invoke();
557	>	threadAssertNull(f.invoke());
558		threadAssertTrue(f.isDone());
559		threadAssertTrue(f.result == 0);
560		}};
561	<	mainPool.invoke(a);
561	>	testInvokeOnPool(mainPool(), a);
562		}
563
564		/**
#	Line 660 | Line 575 | public class RecursiveActionTest extends
575		threadAssertTrue(g.isDone());
576		threadAssertTrue(g.result == 34);
577		}};
578	<	mainPool.invoke(a);
578	>	testInvokeOnPool(mainPool(), a);
579		}
580
581		/**
#	Line 674 | Line 589 | public class RecursiveActionTest extends
589		threadAssertTrue(f.isDone());
590		threadAssertTrue(f.result == 21);
591		}};
592	<	mainPool.invoke(a);
592	>	testInvokeOnPool(mainPool(), a);
593		}
594
595		/**
#	Line 694 | Line 609 | public class RecursiveActionTest extends
609		threadAssertTrue(h.isDone());
610		threadAssertTrue(h.result == 13);
611		}};
612	<	mainPool.invoke(a);
612	>	testInvokeOnPool(mainPool(), a);
613		}
614
615		/**
#	Line 718 | Line 633 | public class RecursiveActionTest extends
633		threadAssertTrue(h.isDone());
634		threadAssertTrue(h.result == 13);
635		}};
636	<	mainPool.invoke(a);
636	>	testInvokeOnPool(mainPool(), a);
637		}
638
639
#	Line 737 | Line 652 | public class RecursiveActionTest extends
652		} catch (NullPointerException success) {
653		}
654		}};
655	<	mainPool.invoke(a);
655	>	testInvokeOnPool(mainPool(), a);
656		}
657
658		/**
#	Line 754 | Line 669 | public class RecursiveActionTest extends
669		} catch (FJException success) {
670		}
671		}};
672	<	mainPool.invoke(a);
672	>	testInvokeOnPool(mainPool(), a);
673		}
674
675		/**
#	Line 770 | Line 685 | public class RecursiveActionTest extends
685		} catch (FJException success) {
686		}
687		}};
688	<	mainPool.invoke(a);
688	>	testInvokeOnPool(mainPool(), a);
689		}
690
691		/**
#	Line 788 | Line 703 | public class RecursiveActionTest extends
703		} catch (FJException success) {
704		}
705		}};
706	<	mainPool.invoke(a);
706	>	testInvokeOnPool(mainPool(), a);
707		}
708
709		/**
#	Line 810 | Line 725 | public class RecursiveActionTest extends
725		} catch (FJException success) {
726		}
727		}};
728	<	mainPool.invoke(a);
728	>	testInvokeOnPool(mainPool(), a);
729		}
730
731		/**
#	Line 821 | Line 736 | public class RecursiveActionTest extends
736		RecursiveAction a = new RecursiveAction() {
737		public void compute() {
738		FibAction g = new FibAction(9);
739	<	g.fork();
739	>	threadAssertSame(g, g.fork());
740		FibAction f = new FibAction(8);
741	<	f.fork();
741	>	threadAssertSame(f, f.fork());
742		threadAssertTrue(f.tryUnfork());
743		helpQuiesce();
744		threadAssertFalse(f.isDone());
745		threadAssertTrue(g.isDone());
746		}};
747	<	singletonPool.invoke(a);
747	>	testInvokeOnPool(singletonPool(), a);
748		}
749
750		/**
#	Line 840 | Line 755 | public class RecursiveActionTest extends
755		RecursiveAction a = new RecursiveAction() {
756		public void compute() {
757		FibAction h = new FibAction(7);
758	<	h.fork();
758	>	threadAssertSame(h, h.fork());
759		FibAction g = new FibAction(9);
760	<	g.fork();
760	>	threadAssertSame(g, g.fork());
761		FibAction f = new FibAction(8);
762	<	f.fork();
762	>	threadAssertSame(f, f.fork());
763		threadAssertTrue(getSurplusQueuedTaskCount() > 0);
764		helpQuiesce();
765		}};
766	<	singletonPool.invoke(a);
766	>	testInvokeOnPool(singletonPool(), a);
767		}
768
769		/**
#	Line 858 | Line 773 | public class RecursiveActionTest extends
773		RecursiveAction a = new RecursiveAction() {
774		public void compute() {
775		FibAction g = new FibAction(9);
776	<	g.fork();
776	>	threadAssertSame(g, g.fork());
777		FibAction f = new FibAction(8);
778	<	f.fork();
778	>	threadAssertSame(f, f.fork());
779		threadAssertTrue(peekNextLocalTask() == f);
780	<	f.join();
780	>	threadAssertNull(f.join());
781		threadAssertTrue(f.isDone());
782		helpQuiesce();
783		}};
784	<	singletonPool.invoke(a);
784	>	testInvokeOnPool(singletonPool(), a);
785		}
786
787		/**
#	Line 877 | Line 792 | public class RecursiveActionTest extends
792		RecursiveAction a = new RecursiveAction() {
793		public void compute() {
794		FibAction g = new FibAction(9);
795	<	g.fork();
795	>	threadAssertSame(g, g.fork());
796		FibAction f = new FibAction(8);
797	<	f.fork();
797	>	threadAssertSame(f, f.fork());
798		threadAssertTrue(pollNextLocalTask() == f);
799		helpQuiesce();
800		threadAssertFalse(f.isDone());
801		}};
802	<	singletonPool.invoke(a);
802	>	testInvokeOnPool(singletonPool(), a);
803		}
804
805		/**
#	Line 895 | Line 810 | public class RecursiveActionTest extends
810		RecursiveAction a = new RecursiveAction() {
811		public void compute() {
812		FibAction g = new FibAction(9);
813	<	g.fork();
813	>	threadAssertSame(g, g.fork());
814		FibAction f = new FibAction(8);
815	<	f.fork();
815	>	threadAssertSame(f, f.fork());
816		threadAssertTrue(pollTask() == f);
817		helpQuiesce();
818		threadAssertFalse(f.isDone());
819		threadAssertTrue(g.isDone());
820		}};
821	<	singletonPool.invoke(a);
821	>	testInvokeOnPool(singletonPool(), a);
822		}
823
824		/**
#	Line 913 | Line 828 | public class RecursiveActionTest extends
828		RecursiveAction a = new RecursiveAction() {
829		public void compute() {
830		FibAction g = new FibAction(9);
831	<	g.fork();
831	>	threadAssertSame(g, g.fork());
832		FibAction f = new FibAction(8);
833	<	f.fork();
833	>	threadAssertSame(f, f.fork());
834		threadAssertTrue(peekNextLocalTask() == g);
835	<	f.join();
835	>	threadAssertNull(f.join());
836		helpQuiesce();
837		threadAssertTrue(f.isDone());
838		}};
839	<	asyncSingletonPool.invoke(a);
839	>	testInvokeOnPool(asyncSingletonPool(), a);
840		}
841
842		/**
#	Line 932 | Line 847 | public class RecursiveActionTest extends
847		RecursiveAction a = new RecursiveAction() {
848		public void compute() {
849		FibAction g = new FibAction(9);
850	<	g.fork();
850	>	threadAssertSame(g, g.fork());
851		FibAction f = new FibAction(8);
852	<	f.fork();
852	>	threadAssertSame(f, f.fork());
853		threadAssertTrue(pollNextLocalTask() == g);
854		helpQuiesce();
855		threadAssertTrue(f.isDone());
856		threadAssertFalse(g.isDone());
857		}};
858	<	asyncSingletonPool.invoke(a);
858	>	testInvokeOnPool(asyncSingletonPool(), a);
859		}
860
861		/**
#	Line 951 | Line 866 | public class RecursiveActionTest extends
866		RecursiveAction a = new RecursiveAction() {
867		public void compute() {
868		FibAction g = new FibAction(9);
869	<	g.fork();
869	>	threadAssertSame(g, g.fork());
870		FibAction f = new FibAction(8);
871	<	f.fork();
871	>	threadAssertSame(f, f.fork());
872		threadAssertTrue(pollTask() == g);
873		helpQuiesce();
874		threadAssertTrue(f.isDone());
875		threadAssertFalse(g.isDone());
876		}};
877	<	asyncSingletonPool.invoke(a);
877	>	testInvokeOnPool(asyncSingletonPool(), a);
878		}
879
880		}

Diff Legend

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