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.8 by jsr166, Sat Nov 21 02:07:27 2009 UTC vs.
Revision 1.16 by jsr166, Mon Sep 13 23:23:45 2010 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/licenses/publicdomain
5		*/
6	–	import junit.framework.*;
7	–	import java.util.concurrent.*;
8	–	import java.util.*;
6
7	+	import junit.framework.*;
8	+	import java.util.concurrent.CancellationException;
9	+	import java.util.concurrent.ExecutionException;
10	+	import java.util.concurrent.ForkJoinPool;
11	+	import java.util.concurrent.RecursiveTask;
12	+	import java.util.concurrent.TimeUnit;
13	+	import java.util.HashSet;
14
15		public class RecursiveTaskTest extends JSR166TestCase {
16
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run(suite());
19		}
20		public static Test suite() {
21		return new TestSuite(RecursiveTaskTest.class);
22		}
23
24	<	static final ForkJoinPool mainPool = new ForkJoinPool();
25	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
26	<	static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
27	<	static {
28	<	asyncSingletonPool.setAsyncMode(true);
24	>	private static ForkJoinPool mainPool() {
25	>	return new ForkJoinPool();
26	>	}
27	>
28	>	private static ForkJoinPool singletonPool() {
29	>	return new ForkJoinPool(1);
30	>	}
31	>
32	>	private static ForkJoinPool asyncSingletonPool() {
33	>	return new ForkJoinPool(1,
34	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
35	>	null, true);
36	>	}
37	>
38	>	private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
39	>	try {
40	>	return pool.invoke(a);
41	>	} finally {
42	>	joinPool(pool);
43	>	}
44		}
45
46		static final class FJException extends RuntimeException {
#	Line 65 | Line 84 | public class RecursiveTaskTest extends J
84		* isCompletedAbnormally and isCancelled return false for normally
85		* completed tasks. getRawResult of a completed non-null task
86		* returns value;
68	–	*
87		*/
88		public void testInvoke() {
89		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 80 | Line 98 | public class RecursiveTaskTest extends J
98		return r;
99		}
100		};
101	<	assertTrue(mainPool.invoke(a) == 21);
101	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
102		}
103
104		/**
#	Line 101 | Line 119 | public class RecursiveTaskTest extends J
119		return r;
120		}
121		};
122	<	assertTrue(mainPool.invoke(a) == 21);
122	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
123		}
124
125		/**
#	Line 111 | Line 129 | public class RecursiveTaskTest extends J
129		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
130		public Integer compute() {
131		FibTask f = new FibTask(8);
132	<	f.fork();
132	>	threadAssertSame(f, f.fork());
133		Integer r = f.join();
134		threadAssertTrue(r == 21);
135		threadAssertTrue(f.isDone());
136		return r;
137		}
138		};
139	<	assertTrue(mainPool.invoke(a) == 21);
139	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
140		}
141
142		/**
#	Line 129 | Line 147 | public class RecursiveTaskTest extends J
147		public Integer compute() {
148		try {
149		FibTask f = new FibTask(8);
150	<	f.fork();
150	>	threadAssertSame(f, f.fork());
151		Integer r = f.get();
152		threadAssertTrue(r == 21);
153		threadAssertTrue(f.isDone());
#	Line 140 | Line 158 | public class RecursiveTaskTest extends J
158		return NoResult;
159		}
160		};
161	<	assertTrue(mainPool.invoke(a) == 21);
161	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
162		}
163
164		/**
#	Line 151 | Line 169 | public class RecursiveTaskTest extends J
169		public Integer compute() {
170		try {
171		FibTask f = new FibTask(8);
172	<	f.fork();
172	>	threadAssertSame(f, f.fork());
173		Integer r = f.get(5L, TimeUnit.SECONDS);
174		threadAssertTrue(r == 21);
175		threadAssertTrue(f.isDone());
#	Line 162 | Line 180 | public class RecursiveTaskTest extends J
180		return NoResult;
181		}
182		};
183	<	assertTrue(mainPool.invoke(a) == 21);
166	<	}
167	<
168	<	/**
169	<	* helpJoin of a forked task returns when task completes
170	<	*/
171	<	public void testForkHelpJoin() {
172	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
173	<	public Integer compute() {
174	<	FibTask f = new FibTask(8);
175	<	f.fork();
176	<	Integer r = f.helpJoin();
177	<	threadAssertTrue(r == 21);
178	<	threadAssertTrue(f.isDone());
179	<	return r;
180	<	}
181	<	};
182	<	assertTrue(mainPool.invoke(a) == 21);
183	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
184		}
185
186		/**
#	Line 189 | Line 190 | public class RecursiveTaskTest extends J
190		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
191		public Integer compute() {
192		FibTask f = new FibTask(8);
193	<	f.fork();
193	>	threadAssertSame(f, f.fork());
194		f.quietlyJoin();
195		Integer r = f.getRawResult();
196		threadAssertTrue(r == 21);
#	Line 197 | Line 198 | public class RecursiveTaskTest extends J
198		return r;
199		}
200		};
201	<	assertTrue(mainPool.invoke(a) == 21);
201	<	}
202	<
203	<
204	<	/**
205	<	* quietlyHelpJoin of a forked task returns when task completes
206	<	*/
207	<	public void testForkQuietlyHelpJoin() {
208	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
209	<	public Integer compute() {
210	<	FibTask f = new FibTask(8);
211	<	f.fork();
212	<	f.quietlyHelpJoin();
213	<	Integer r = f.getRawResult();
214	<	threadAssertTrue(r == 21);
215	<	threadAssertTrue(f.isDone());
216	<	return r;
217	<	}
218	<	};
219	<	assertTrue(mainPool.invoke(a) == 21);
201	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
202		}
203
204
#	Line 228 | Line 210 | public class RecursiveTaskTest extends J
210		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
211		public Integer compute() {
212		FibTask f = new FibTask(8);
213	<	f.fork();
213	>	threadAssertSame(f, f.fork());
214		f.helpQuiesce();
215		Integer r = f.getRawResult();
216		threadAssertTrue(r == 21);
#	Line 237 | Line 219 | public class RecursiveTaskTest extends J
219		return r;
220		}
221		};
222	<	assertTrue(mainPool.invoke(a) == 21);
222	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
223		}
224
225
#	Line 257 | Line 239 | public class RecursiveTaskTest extends J
239		return NoResult;
240		}
241		};
242	<	mainPool.invoke(a);
242	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
243		}
244
245		/**
#	Line 272 | Line 254 | public class RecursiveTaskTest extends J
254		return NoResult;
255		}
256		};
257	<	mainPool.invoke(a);
257	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
258		}
259
260		/**
#	Line 283 | Line 265 | public class RecursiveTaskTest extends J
265		public Integer compute() {
266		try {
267		FailingFibTask f = new FailingFibTask(8);
268	<	f.fork();
268	>	threadAssertSame(f, f.fork());
269		Integer r = f.join();
270		shouldThrow();
271		return r;
#	Line 292 | Line 274 | public class RecursiveTaskTest extends J
274		return NoResult;
275		}
276		};
277	<	mainPool.invoke(a);
277	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
278		}
279
280		/**
#	Line 303 | Line 285 | public class RecursiveTaskTest extends J
285		public Integer compute() {
286		try {
287		FailingFibTask f = new FailingFibTask(8);
288	<	f.fork();
288	>	threadAssertSame(f, f.fork());
289		Integer r = f.get();
290		shouldThrow();
291		return r;
#	Line 314 | Line 296 | public class RecursiveTaskTest extends J
296		return NoResult;
297		}
298		};
299	<	mainPool.invoke(a);
299	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
300		}
301
302		/**
#	Line 325 | Line 307 | public class RecursiveTaskTest extends J
307		public Integer compute() {
308		try {
309		FailingFibTask f = new FailingFibTask(8);
310	<	f.fork();
310	>	threadAssertSame(f, f.fork());
311		Integer r = f.get(5L, TimeUnit.SECONDS);
312		shouldThrow();
313		return r;
#	Line 336 | Line 318 | public class RecursiveTaskTest extends J
318		return NoResult;
319		}
320		};
321	<	mainPool.invoke(a);
340	<	}
341	<
342	<	/**
343	<	* join of a forked task throws exception when task completes abnormally
344	<	*/
345	<	public void testAbnormalForkHelpJoin() {
346	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
347	<	public Integer compute() {
348	<	try {
349	<	FailingFibTask f = new FailingFibTask(8);
350	<	f.fork();
351	<	Integer r = f.helpJoin();
352	<	shouldThrow();
353	<	return r;
354	<	} catch (FJException success) {
355	<	}
356	<	return NoResult;
357	<	}
358	<	};
359	<	mainPool.invoke(a);
360	<	}
361	<
362	<	/**
363	<	* quietlyHelpJoin of a forked task returns when task completes abnormally.
364	<	* getException of failed task returns its exception.
365	<	* isCompletedAbnormally of a failed task returns true.
366	<	* isCancelled of a failed uncancelled task returns false
367	<	*/
368	<	public void testAbnormalForkQuietlyHelpJoin() {
369	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
370	<	public Integer compute() {
371	<	FailingFibTask f = new FailingFibTask(8);
372	<	f.fork();
373	<	f.quietlyHelpJoin();
374	<	threadAssertTrue(f.isDone());
375	<	threadAssertTrue(f.isCompletedAbnormally());
376	<	threadAssertFalse(f.isCancelled());
377	<	threadAssertTrue(f.getException() instanceof FJException);
378	<	return NoResult;
379	<	}
380	<	};
381	<	mainPool.invoke(a);
321	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
322		}
323
324		/**
#	Line 388 | Line 328 | public class RecursiveTaskTest extends J
328		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
329		public Integer compute() {
330		FailingFibTask f = new FailingFibTask(8);
331	<	f.fork();
331	>	threadAssertSame(f, f.fork());
332		f.quietlyJoin();
333		threadAssertTrue(f.isDone());
334		threadAssertTrue(f.isCompletedAbnormally());
#	Line 396 | Line 336 | public class RecursiveTaskTest extends J
336		return NoResult;
337		}
338		};
339	<	mainPool.invoke(a);
339	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
340		}
341
342		/**
#	Line 407 | Line 347 | public class RecursiveTaskTest extends J
347		public Integer compute() {
348		try {
349		FibTask f = new FibTask(8);
350	<	f.cancel(true);
350	>	threadAssertTrue(f.cancel(true));
351		Integer r = f.invoke();
352		shouldThrow();
353		return r;
#	Line 416 | Line 356 | public class RecursiveTaskTest extends J
356		return NoResult;
357		}
358		};
359	<	mainPool.invoke(a);
359	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
360		}
361
362		/**
#	Line 427 | Line 367 | public class RecursiveTaskTest extends J
367		public Integer compute() {
368		try {
369		FibTask f = new FibTask(8);
370	<	f.cancel(true);
371	<	f.fork();
370	>	threadAssertTrue(f.cancel(true));
371	>	threadAssertSame(f, f.fork());
372		Integer r = f.join();
373		shouldThrow();
374		return r;
#	Line 437 | Line 377 | public class RecursiveTaskTest extends J
377		return NoResult;
378		}
379		};
380	<	mainPool.invoke(a);
380	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
381		}
382
383		/**
#	Line 448 | Line 388 | public class RecursiveTaskTest extends J
388		public Integer compute() {
389		try {
390		FibTask f = new FibTask(8);
391	<	f.cancel(true);
392	<	f.fork();
391	>	threadAssertTrue(f.cancel(true));
392	>	threadAssertSame(f, f.fork());
393		Integer r = f.get();
394		shouldThrow();
395		return r;
#	Line 460 | Line 400 | public class RecursiveTaskTest extends J
400		return NoResult;
401		}
402		};
403	<	mainPool.invoke(a);
403	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
404		}
405
406		/**
#	Line 471 | Line 411 | public class RecursiveTaskTest extends J
411		public Integer compute() {
412		try {
413		FibTask f = new FibTask(8);
414	<	f.cancel(true);
415	<	f.fork();
414	>	threadAssertTrue(f.cancel(true));
415	>	threadAssertSame(f, f.fork());
416		Integer r = f.get(5L, TimeUnit.SECONDS);
417		shouldThrow();
418		return r;
#	Line 483 | Line 423 | public class RecursiveTaskTest extends J
423		return NoResult;
424		}
425		};
426	<	mainPool.invoke(a);
487	<	}
488	<
489	<	/**
490	<	* join of a forked task throws exception when task cancelled
491	<	*/
492	<	public void testCancelledForkHelpJoin() {
493	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
494	<	public Integer compute() {
495	<	try {
496	<	FibTask f = new FibTask(8);
497	<	f.cancel(true);
498	<	f.fork();
499	<	Integer r = f.helpJoin();
500	<	shouldThrow();
501	<	return r;
502	<	} catch (CancellationException success) {
503	<	}
504	<	return NoResult;
505	<	}
506	<	};
507	<	mainPool.invoke(a);
508	<	}
509	<
510	<	/**
511	<	* quietlyHelpJoin of a forked task returns when task cancelled.
512	<	* getException of cancelled task returns its exception
513	<	* isCompletedAbnormally of a cancelled task returns true.
514	<	* isCancelled of a cancelled task returns true
515	<	*/
516	<	public void testCancelledForkQuietlyHelpJoin() {
517	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
518	<	public Integer compute() {
519	<	FibTask f = new FibTask(8);
520	<	f.cancel(true);
521	<	f.fork();
522	<	f.quietlyHelpJoin();
523	<	threadAssertTrue(f.isDone());
524	<	threadAssertTrue(f.isCompletedAbnormally());
525	<	threadAssertTrue(f.isCancelled());
526	<	threadAssertTrue(f.getException() instanceof CancellationException);
527	<	return NoResult;
528	<	}
529	<	};
530	<	mainPool.invoke(a);
426	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
427		}
428
429		/**
#	Line 537 | Line 433 | public class RecursiveTaskTest extends J
433		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
434		public Integer compute() {
435		FibTask f = new FibTask(8);
436	<	f.cancel(true);
437	<	f.fork();
436	>	threadAssertTrue(f.cancel(true));
437	>	threadAssertSame(f, f.fork());
438		f.quietlyJoin();
439		threadAssertTrue(f.isDone());
440		threadAssertTrue(f.isCompletedAbnormally());
#	Line 546 | Line 442 | public class RecursiveTaskTest extends J
442		return NoResult;
443		}
444		};
445	<	mainPool.invoke(a);
445	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
446		}
447
448		/**
449		* getPool of executing task returns its pool
450		*/
451		public void testGetPool() {
452	+	final ForkJoinPool mainPool = mainPool();
453		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
454		public Integer compute() {
455		threadAssertTrue(getPool() == mainPool);
456		return NoResult;
457		}
458		};
459	<	mainPool.invoke(a);
459	>	assertSame(NoResult, testInvokeOnPool(mainPool, a));
460		}
461
462		/**
#	Line 572 | Line 469 | public class RecursiveTaskTest extends J
469		return NoResult;
470		}
471		};
472	<	a.invoke();
472	>	assertSame(NoResult, a.invoke());
473		}
474
475		/**
#	Line 585 | Line 482 | public class RecursiveTaskTest extends J
482		return NoResult;
483		}
484		};
485	<	mainPool.invoke(a);
485	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
486		}
487
488		/**
#	Line 598 | Line 495 | public class RecursiveTaskTest extends J
495		return NoResult;
496		}
497		};
498	<	a.invoke();
498	>	assertSame(NoResult, a.invoke());
499		}
500
501		/**
502	<	* setRawResult(null) succeeds
502	>	* The value set by setRawResult is returned by invoke
503		*/
504		public void testSetRawResult() {
505		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 611 | Line 508 | public class RecursiveTaskTest extends J
508		return NoResult;
509		}
510		};
511	<	assertEquals(a.invoke(), NoResult);
511	>	assertSame(NoResult, a.invoke());
512		}
513
514		/**
#	Line 632 | Line 529 | public class RecursiveTaskTest extends J
529		return NoResult;
530		}
531		};
532	<	mainPool.invoke(a);
532	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
533		}
534
535		/**
#	Line 652 | Line 549 | public class RecursiveTaskTest extends J
549		return NoResult;
550		}
551		};
552	<	mainPool.invoke(a);
552	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
553		}
554
555		/**
#	Line 669 | Line 566 | public class RecursiveTaskTest extends J
566		return r;
567		}
568		};
569	<	mainPool.invoke(a);
569	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
570		}
571
572		/**
#	Line 688 | Line 585 | public class RecursiveTaskTest extends J
585		return NoResult;
586		}
587		};
588	<	mainPool.invoke(a);
588	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
589		}
590
591		/**
#	Line 704 | Line 601 | public class RecursiveTaskTest extends J
601		return NoResult;
602		}
603		};
604	<	mainPool.invoke(a);
604	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
605		}
606
607		/**
#	Line 726 | Line 623 | public class RecursiveTaskTest extends J
623		return NoResult;
624		}
625		};
626	<	mainPool.invoke(a);
626	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
627		}
628
629		/**
#	Line 752 | Line 649 | public class RecursiveTaskTest extends J
649		return NoResult;
650		}
651		};
652	<	mainPool.invoke(a);
652	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
653		}
654
655
#	Line 773 | Line 670 | public class RecursiveTaskTest extends J
670		return NoResult;
671		}
672		};
673	<	mainPool.invoke(a);
673	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
674		}
675
676		/**
#	Line 792 | Line 689 | public class RecursiveTaskTest extends J
689		return NoResult;
690		}
691		};
692	<	mainPool.invoke(a);
692	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
693		}
694
695		/**
#	Line 813 | Line 710 | public class RecursiveTaskTest extends J
710		return NoResult;
711		}
712		};
713	<	mainPool.invoke(a);
713	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
714		}
715
716		/**
#	Line 838 | Line 735 | public class RecursiveTaskTest extends J
735		return NoResult;
736		}
737		};
738	<	mainPool.invoke(a);
738	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
739		}
740
741		/**
#	Line 849 | Line 746 | public class RecursiveTaskTest extends J
746		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
747		public Integer compute() {
748		FibTask g = new FibTask(9);
749	<	g.fork();
749	>	threadAssertSame(g, g.fork());
750		FibTask f = new FibTask(8);
751	<	f.fork();
751	>	threadAssertSame(f, f.fork());
752		threadAssertTrue(f.tryUnfork());
753		helpQuiesce();
754		threadAssertFalse(f.isDone());
#	Line 859 | Line 756 | public class RecursiveTaskTest extends J
756		return NoResult;
757		}
758		};
759	<	singletonPool.invoke(a);
759	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
760		}
761
762		/**
#	Line 870 | Line 767 | public class RecursiveTaskTest extends J
767		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
768		public Integer compute() {
769		FibTask h = new FibTask(7);
770	<	h.fork();
770	>	threadAssertSame(h, h.fork());
771		FibTask g = new FibTask(9);
772	<	g.fork();
772	>	threadAssertSame(g, g.fork());
773		FibTask f = new FibTask(8);
774	<	f.fork();
774	>	threadAssertSame(f, f.fork());
775		threadAssertTrue(getSurplusQueuedTaskCount() > 0);
776		helpQuiesce();
777		return NoResult;
778		}
779		};
780	<	singletonPool.invoke(a);
780	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
781		}
782
783		/**
#	Line 890 | Line 787 | public class RecursiveTaskTest extends J
787		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
788		public Integer compute() {
789		FibTask g = new FibTask(9);
790	<	g.fork();
790	>	threadAssertSame(g, g.fork());
791		FibTask f = new FibTask(8);
792	<	f.fork();
792	>	threadAssertSame(f, f.fork());
793		threadAssertTrue(peekNextLocalTask() == f);
794	<	f.join();
794	>	threadAssertTrue(f.join() == 21);
795		threadAssertTrue(f.isDone());
796		helpQuiesce();
797		return NoResult;
798		}
799		};
800	<	singletonPool.invoke(a);
800	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
801		}
802
803		/**
#	Line 911 | Line 808 | public class RecursiveTaskTest extends J
808		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
809		public Integer compute() {
810		FibTask g = new FibTask(9);
811	<	g.fork();
811	>	threadAssertSame(g, g.fork());
812		FibTask f = new FibTask(8);
813	<	f.fork();
813	>	threadAssertSame(f, f.fork());
814		threadAssertTrue(pollNextLocalTask() == f);
815		helpQuiesce();
816		threadAssertFalse(f.isDone());
817		return NoResult;
818		}
819		};
820	<	singletonPool.invoke(a);
820	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
821		}
822
823		/**
824	<	* pollTask returns an unexecuted task
928	<	* without executing it
824	>	* pollTask returns an unexecuted task without executing it
825		*/
826		public void testPollTask() {
827		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
828		public Integer compute() {
829		FibTask g = new FibTask(9);
830	<	g.fork();
830	>	threadAssertSame(g, g.fork());
831		FibTask f = new FibTask(8);
832	<	f.fork();
832	>	threadAssertSame(f, f.fork());
833		threadAssertTrue(pollTask() == f);
834		helpQuiesce();
835		threadAssertFalse(f.isDone());
#	Line 941 | Line 837 | public class RecursiveTaskTest extends J
837		return NoResult;
838		}
839		};
840	<	singletonPool.invoke(a);
840	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
841		}
842
843		/**
#	Line 951 | Line 847 | public class RecursiveTaskTest extends J
847		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
848		public Integer compute() {
849		FibTask g = new FibTask(9);
850	<	g.fork();
850	>	threadAssertSame(g, g.fork());
851		FibTask f = new FibTask(8);
852	<	f.fork();
852	>	threadAssertSame(f, f.fork());
853		threadAssertTrue(peekNextLocalTask() == g);
854	<	f.join();
854	>	threadAssertEquals(21, (int) f.join());
855		helpQuiesce();
856		threadAssertTrue(f.isDone());
857		return NoResult;
858		}
859		};
860	<	asyncSingletonPool.invoke(a);
860	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
861		}
862
863		/**
#	Line 972 | Line 868 | public class RecursiveTaskTest extends J
868		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
869		public Integer compute() {
870		FibTask g = new FibTask(9);
871	<	g.fork();
871	>	threadAssertSame(g, g.fork());
872		FibTask f = new FibTask(8);
873	<	f.fork();
873	>	threadAssertSame(f, f.fork());
874		threadAssertTrue(pollNextLocalTask() == g);
875		helpQuiesce();
876		threadAssertTrue(f.isDone());
#	Line 982 | Line 878 | public class RecursiveTaskTest extends J
878		return NoResult;
879		}
880		};
881	<	asyncSingletonPool.invoke(a);
881	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
882		}
883
884		/**
#	Line 993 | Line 889 | public class RecursiveTaskTest extends J
889		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
890		public Integer compute() {
891		FibTask g = new FibTask(9);
892	<	g.fork();
892	>	threadAssertSame(g, g.fork());
893		FibTask f = new FibTask(8);
894	<	f.fork();
894	>	threadAssertSame(f, f.fork());
895		threadAssertTrue(pollTask() == g);
896		helpQuiesce();
897		threadAssertTrue(f.isDone());
#	Line 1003 | Line 899 | public class RecursiveTaskTest extends J
899		return NoResult;
900		}
901		};
902	<	asyncSingletonPool.invoke(a);
902	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
903		}
904
905		}

Diff Legend

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