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.12 by jsr166, Sat Sep 11 07:31:52 2010 UTC vs.
Revision 1.13 by jsr166, Mon Sep 13 07:51:18 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	+
7		import junit.framework.*;
8		import java.util.concurrent.*;
9		import java.util.*;
10
10	–
11		public class RecursiveTaskTest extends JSR166TestCase {
12
13		public static void main(String[] args) {
#	Line 17 | Line 17 | public class RecursiveTaskTest extends J
17		return new TestSuite(RecursiveTaskTest.class);
18		}
19
20	<	static final ForkJoinPool mainPool = new ForkJoinPool();
21	<	static final ForkJoinPool singletonPool = new ForkJoinPool(1);
22	<	static final ForkJoinPool asyncSingletonPool =
23	<	new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory,
24	<	null, true);
20	>	private static ForkJoinPool mainPool() {
21	>	return new ForkJoinPool();
22	>	}
23	>
24	>	private static ForkJoinPool singletonPool() {
25	>	return new ForkJoinPool(1);
26	>	}
27	>
28	>	private static ForkJoinPool asyncSingletonPool() {
29	>	return new ForkJoinPool(1,
30	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
31	>	null, true);
32	>	}
33	>
34	>	private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
35	>	try {
36	>	return pool.invoke(a);
37	>	} finally {
38	>	joinPool(pool);
39	>	}
40	>	}
41
42		static final class FJException extends RuntimeException {
43		FJException() { super(); }
#	Line 78 | Line 94 | public class RecursiveTaskTest extends J
94		return r;
95		}
96		};
97	<	assertTrue(mainPool.invoke(a) == 21);
97	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
98		}
99
100		/**
#	Line 99 | Line 115 | public class RecursiveTaskTest extends J
115		return r;
116		}
117		};
118	<	assertTrue(mainPool.invoke(a) == 21);
118	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
119		}
120
121		/**
#	Line 116 | Line 132 | public class RecursiveTaskTest extends J
132		return r;
133		}
134		};
135	<	assertTrue(mainPool.invoke(a) == 21);
135	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
136		}
137
138		/**
#	Line 138 | Line 154 | public class RecursiveTaskTest extends J
154		return NoResult;
155		}
156		};
157	<	assertTrue(mainPool.invoke(a) == 21);
157	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
158		}
159
160		/**
#	Line 160 | Line 176 | public class RecursiveTaskTest extends J
176		return NoResult;
177		}
178		};
179	<	assertTrue(mainPool.invoke(a) == 21);
179	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
180		}
181
182		/**
#	Line 178 | Line 194 | public class RecursiveTaskTest extends J
194		return r;
195		}
196		};
197	<	assertTrue(mainPool.invoke(a) == 21);
197	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
198		}
199
200
#	Line 199 | Line 215 | public class RecursiveTaskTest extends J
215		return r;
216		}
217		};
218	<	assertTrue(mainPool.invoke(a) == 21);
218	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
219		}
220
221
#	Line 219 | Line 235 | public class RecursiveTaskTest extends J
235		return NoResult;
236		}
237		};
238	<	mainPool.invoke(a);
238	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
239		}
240
241		/**
#	Line 234 | Line 250 | public class RecursiveTaskTest extends J
250		return NoResult;
251		}
252		};
253	<	mainPool.invoke(a);
253	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
254		}
255
256		/**
#	Line 254 | Line 270 | public class RecursiveTaskTest extends J
270		return NoResult;
271		}
272		};
273	<	mainPool.invoke(a);
273	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
274		}
275
276		/**
#	Line 276 | Line 292 | public class RecursiveTaskTest extends J
292		return NoResult;
293		}
294		};
295	<	mainPool.invoke(a);
295	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
296		}
297
298		/**
#	Line 298 | Line 314 | public class RecursiveTaskTest extends J
314		return NoResult;
315		}
316		};
317	<	mainPool.invoke(a);
317	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
318		}
319
320		/**
#	Line 316 | Line 332 | public class RecursiveTaskTest extends J
332		return NoResult;
333		}
334		};
335	<	mainPool.invoke(a);
335	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
336		}
337
338		/**
#	Line 336 | Line 352 | public class RecursiveTaskTest extends J
352		return NoResult;
353		}
354		};
355	<	mainPool.invoke(a);
355	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
356		}
357
358		/**
#	Line 357 | Line 373 | public class RecursiveTaskTest extends J
373		return NoResult;
374		}
375		};
376	<	mainPool.invoke(a);
376	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
377		}
378
379		/**
#	Line 380 | Line 396 | public class RecursiveTaskTest extends J
396		return NoResult;
397		}
398		};
399	<	mainPool.invoke(a);
399	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
400		}
401
402		/**
#	Line 403 | Line 419 | public class RecursiveTaskTest extends J
419		return NoResult;
420		}
421		};
422	<	mainPool.invoke(a);
422	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
423		}
424
425		/**
#	Line 422 | Line 438 | public class RecursiveTaskTest extends J
438		return NoResult;
439		}
440		};
441	<	mainPool.invoke(a);
441	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
442		}
443
444		/**
445		* getPool of executing task returns its pool
446		*/
447		public void testGetPool() {
448	+	final ForkJoinPool mainPool = mainPool();
449		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
450		public Integer compute() {
451		threadAssertTrue(getPool() == mainPool);
452		return NoResult;
453		}
454		};
455	<	mainPool.invoke(a);
455	>	assertSame(NoResult, testInvokeOnPool(mainPool, a));
456		}
457
458		/**
#	Line 461 | Line 478 | public class RecursiveTaskTest extends J
478		return NoResult;
479		}
480		};
481	<	mainPool.invoke(a);
481	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
482		}
483
484		/**
#	Line 487 | Line 504 | public class RecursiveTaskTest extends J
504		return NoResult;
505		}
506		};
507	<	assertEquals(a.invoke(), NoResult);
507	>	assertSame(NoResult, a.invoke());
508		}
509
510		/**
#	Line 508 | Line 525 | public class RecursiveTaskTest extends J
525		return NoResult;
526		}
527		};
528	<	mainPool.invoke(a);
528	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
529		}
530
531		/**
#	Line 528 | Line 545 | public class RecursiveTaskTest extends J
545		return NoResult;
546		}
547		};
548	<	mainPool.invoke(a);
548	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
549		}
550
551		/**
#	Line 545 | Line 562 | public class RecursiveTaskTest extends J
562		return r;
563		}
564		};
565	<	mainPool.invoke(a);
565	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
566		}
567
568		/**
#	Line 564 | Line 581 | public class RecursiveTaskTest extends J
581		return NoResult;
582		}
583		};
584	<	mainPool.invoke(a);
584	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
585		}
586
587		/**
#	Line 580 | Line 597 | public class RecursiveTaskTest extends J
597		return NoResult;
598		}
599		};
600	<	mainPool.invoke(a);
600	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
601		}
602
603		/**
#	Line 602 | Line 619 | public class RecursiveTaskTest extends J
619		return NoResult;
620		}
621		};
622	<	mainPool.invoke(a);
622	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
623		}
624
625		/**
#	Line 628 | Line 645 | public class RecursiveTaskTest extends J
645		return NoResult;
646		}
647		};
648	<	mainPool.invoke(a);
648	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
649		}
650
651
#	Line 649 | Line 666 | public class RecursiveTaskTest extends J
666		return NoResult;
667		}
668		};
669	<	mainPool.invoke(a);
669	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
670		}
671
672		/**
#	Line 668 | Line 685 | public class RecursiveTaskTest extends J
685		return NoResult;
686		}
687		};
688	<	mainPool.invoke(a);
688	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
689		}
690
691		/**
#	Line 689 | Line 706 | public class RecursiveTaskTest extends J
706		return NoResult;
707		}
708		};
709	<	mainPool.invoke(a);
709	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
710		}
711
712		/**
#	Line 714 | Line 731 | public class RecursiveTaskTest extends J
731		return NoResult;
732		}
733		};
734	<	mainPool.invoke(a);
734	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
735		}
736
737		/**
#	Line 735 | Line 752 | public class RecursiveTaskTest extends J
752		return NoResult;
753		}
754		};
755	<	singletonPool.invoke(a);
755	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
756		}
757
758		/**
#	Line 756 | Line 773 | public class RecursiveTaskTest extends J
773		return NoResult;
774		}
775		};
776	<	singletonPool.invoke(a);
776	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
777		}
778
779		/**
#	Line 776 | Line 793 | public class RecursiveTaskTest extends J
793		return NoResult;
794		}
795		};
796	<	singletonPool.invoke(a);
796	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
797		}
798
799		/**
#	Line 796 | Line 813 | public class RecursiveTaskTest extends J
813		return NoResult;
814		}
815		};
816	<	singletonPool.invoke(a);
816	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
817		}
818
819		/**
820	<	* pollTask returns an unexecuted task
804	<	* without executing it
820	>	* pollTask returns an unexecuted task without executing it
821		*/
822		public void testPollTask() {
823		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 817 | Line 833 | public class RecursiveTaskTest extends J
833		return NoResult;
834		}
835		};
836	<	singletonPool.invoke(a);
836	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
837		}
838
839		/**
#	Line 837 | Line 853 | public class RecursiveTaskTest extends J
853		return NoResult;
854		}
855		};
856	<	asyncSingletonPool.invoke(a);
856	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
857		}
858
859		/**
#	Line 858 | Line 874 | public class RecursiveTaskTest extends J
874		return NoResult;
875		}
876		};
877	<	asyncSingletonPool.invoke(a);
877	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
878		}
879
880		/**
#	Line 879 | Line 895 | public class RecursiveTaskTest extends J
895		return NoResult;
896		}
897		};
898	<	asyncSingletonPool.invoke(a);
898	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
899		}
900
901		}

Diff Legend

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