ViewVC Help

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

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

Comparing jsr166/src/test/tck/RecursiveTaskTest.java (file contents):
Revision 1.11 by jsr166, Wed Sep 1 06:41:55 2010 UTC vs.
Revision 1.15 by jsr166, Mon Sep 13 20:48:58 2010 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/licenses/publicdomain
5		*/
6	–	import junit.framework.*;
7	–	import java.util.concurrent.*;
8	–	import java.util.*;
6
7	+	import junit.framework.*;
8	+	import java.util.concurrent.CancellationException;
9	+	import java.util.concurrent.ExecutionException;
10	+	import java.util.concurrent.ForkJoinPool;
11	+	import java.util.concurrent.RecursiveTask;
12	+	import java.util.concurrent.TimeUnit;
13	+	import java.util.HashSet;
14
15		public class RecursiveTaskTest extends JSR166TestCase {
16
#	Line 17 | Line 21 | public class RecursiveTaskTest extends J
21		return new TestSuite(RecursiveTaskTest.class);
22		}
23
24	<	static final ForkJoinPool mainPool = new ForkJoinPool();
25	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
26	<	static final ForkJoinPool asyncSingletonPool =
27	<	new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory,
28	<	null, true);
24	>	private static ForkJoinPool mainPool() {
25	>	return new ForkJoinPool();
26	>	}
27	>
28	>	private static ForkJoinPool singletonPool() {
29	>	return new ForkJoinPool(1);
30	>	}
31	>
32	>	private static ForkJoinPool asyncSingletonPool() {
33	>	return new ForkJoinPool(1,
34	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
35	>	null, true);
36	>	}
37	>
38	>	private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
39	>	try {
40	>	return pool.invoke(a);
41	>	} finally {
42	>	joinPool(pool);
43	>	}
44	>	}
45
46		static final class FJException extends RuntimeException {
47		FJException() { super(); }
#	Line 64 | 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;
67	–	*
87		*/
88		public void testInvoke() {
89		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 79 | 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 100 | 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 117 | Line 136 | public class RecursiveTaskTest extends J
136		return r;
137		}
138		};
139	<	assertTrue(mainPool.invoke(a) == 21);
139	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
140		}
141
142		/**
#	Line 139 | 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 161 | Line 180 | public class RecursiveTaskTest extends J
180		return NoResult;
181		}
182		};
183	<	assertTrue(mainPool.invoke(a) == 21);
183	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
184		}
185
186		/**
#	Line 179 | Line 198 | public class RecursiveTaskTest extends J
198		return r;
199		}
200		};
201	<	assertTrue(mainPool.invoke(a) == 21);
201	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
202		}
203
204
#	Line 200 | 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 220 | 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 235 | 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 255 | 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 277 | 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 299 | Line 318 | public class RecursiveTaskTest extends J
318		return NoResult;
319		}
320		};
321	<	mainPool.invoke(a);
321	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
322		}
323
324		/**
#	Line 317 | 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 337 | 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 358 | 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 381 | 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 404 | Line 423 | public class RecursiveTaskTest extends J
423		return NoResult;
424		}
425		};
426	<	mainPool.invoke(a);
426	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
427		}
428
429		/**
#	Line 423 | 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 462 | 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 479 | Line 499 | public class RecursiveTaskTest extends J
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 488 | 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 509 | 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 529 | 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 546 | 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 565 | 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 581 | 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 603 | 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 629 | 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 650 | 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 669 | 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 690 | 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 715 | 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 736 | 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 757 | Line 777 | public class RecursiveTaskTest extends J
777		return NoResult;
778		}
779		};
780	<	singletonPool.invoke(a);
780	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
781		}
782
783		/**
#	Line 777 | Line 797 | public class RecursiveTaskTest extends J
797		return NoResult;
798		}
799		};
800	<	singletonPool.invoke(a);
800	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
801		}
802
803		/**
#	Line 797 | Line 817 | public class RecursiveTaskTest extends J
817		return NoResult;
818		}
819		};
820	<	singletonPool.invoke(a);
820	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
821		}
822
823		/**
824	<	* pollTask returns an unexecuted task
805	<	* without executing it
824	>	* pollTask returns an unexecuted task without executing it
825		*/
826		public void testPollTask() {
827		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 818 | 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 838 | Line 857 | public class RecursiveTaskTest extends J
857		return NoResult;
858		}
859		};
860	<	asyncSingletonPool.invoke(a);
860	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
861		}
862
863		/**
#	Line 859 | 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 880 | 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