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.18 by jsr166, Thu Sep 16 00:52:49 2010 UTC vs.
Revision 1.19 by jsr166, Sun Nov 21 08:25:10 2010 UTC

#	Line 11 | Line 11 | 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.concurrent.TimeoutException;
15	+	import static java.util.concurrent.TimeUnit.SECONDS;
16		import java.util.HashSet;
17
18		public class RecursiveActionTest extends JSR166TestCase {
#	Line 39 | Line 41 | public class RecursiveActionTest extends
41
42		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
43		try {
44	<	assertFalse(a.isDone());
43	<	assertFalse(a.isCompletedNormally());
44	<	assertFalse(a.isCompletedAbnormally());
45	<	assertFalse(a.isCancelled());
46	<	assertNull(a.getException());
44	>	checkNotDone(a);
45
46		assertNull(pool.invoke(a));
47
48	<	assertTrue(a.isDone());
51	<	assertTrue(a.isCompletedNormally());
52	<	assertFalse(a.isCompletedAbnormally());
53	<	assertFalse(a.isCancelled());
54	<	assertNull(a.getException());
48	>	checkCompletedNormally(a);
49		} finally {
50		joinPool(pool);
51		}
52		}
53
54	+	void checkNotDone(RecursiveAction a) {
55	+	assertFalse(a.isDone());
56	+	assertFalse(a.isCompletedNormally());
57	+	assertFalse(a.isCompletedAbnormally());
58	+	assertFalse(a.isCancelled());
59	+	assertNull(a.getException());
60	+	assertNull(a.getRawResult());
61	+
62	+	if (! (Thread.currentThread() instanceof ForkJoinWorkerThread)) {
63	+	Thread.currentThread().interrupt();
64	+	try {
65	+	a.get();
66	+	shouldThrow();
67	+	} catch (InterruptedException success) {
68	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
69	+
70	+	Thread.currentThread().interrupt();
71	+	try {
72	+	a.get(5L, SECONDS);
73	+	shouldThrow();
74	+	} catch (InterruptedException success) {
75	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
76	+	}
77	+
78	+	try {
79	+	a.get(0L, SECONDS);
80	+	shouldThrow();
81	+	} catch (TimeoutException success) {
82	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
83	+	}
84	+
85	+	void checkCompletedNormally(RecursiveAction a) {
86	+	assertTrue(a.isDone());
87	+	assertFalse(a.isCancelled());
88	+	assertTrue(a.isCompletedNormally());
89	+	assertFalse(a.isCompletedAbnormally());
90	+	assertNull(a.getException());
91	+	assertNull(a.getRawResult());
92	+	assertNull(a.join());
93	+	try {
94	+	assertNull(a.get());
95	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
96	+	try {
97	+	assertNull(a.get(5L, SECONDS));
98	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
99	+	}
100	+
101	+	void checkCancelled(RecursiveAction a) {
102	+	assertTrue(a.isDone());
103	+	assertTrue(a.isCancelled());
104	+	assertFalse(a.isCompletedNormally());
105	+	assertTrue(a.isCompletedAbnormally());
106	+	assertTrue(a.getException() instanceof CancellationException);
107	+	assertNull(a.getRawResult());
108	+
109	+	try {
110	+	a.join();
111	+	shouldThrow();
112	+	} catch (CancellationException success) {
113	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
114	+
115	+	try {
116	+	a.get();
117	+	shouldThrow();
118	+	} catch (CancellationException success) {
119	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
120	+
121	+	try {
122	+	a.get(5L, SECONDS);
123	+	shouldThrow();
124	+	} catch (CancellationException success) {
125	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
126	+	}
127	+
128	+	void checkTaskThrew(RecursiveAction a, Throwable t) {
129	+	assertTrue(a.isDone());
130	+	assertFalse(a.isCancelled());
131	+	assertFalse(a.isCompletedNormally());
132	+	assertTrue(a.isCompletedAbnormally());
133	+	assertSame(t, a.getException());
134	+	assertNull(a.getRawResult());
135	+
136	+	try {
137	+	a.join();
138	+	shouldThrow();
139	+	} catch (Throwable expected) {
140	+	assertSame(t, expected);
141	+	}
142	+
143	+	try {
144	+	a.get();
145	+	shouldThrow();
146	+	} catch (ExecutionException success) {
147	+	assertSame(t, success.getCause());
148	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
149	+
150	+	try {
151	+	a.get(5L, SECONDS);
152	+	shouldThrow();
153	+	} catch (ExecutionException success) {
154	+	assertSame(t, success.getCause());
155	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
156	+	}
157	+
158		static final class FJException extends RuntimeException {
159		FJException() { super(); }
160		}
#	Line 108 | Line 206 | public class RecursiveActionTest extends
206		FibAction f = new FibAction(8);
207		assertNull(f.invoke());
208		assertEquals(21, f.result);
209	<	assertTrue(f.isDone());
112	<	assertFalse(f.isCancelled());
113	<	assertFalse(f.isCompletedAbnormally());
114	<	assertNull(f.getRawResult());
209	>	checkCompletedNormally(f);
210		}};
211		testInvokeOnPool(mainPool(), a);
212		}
#	Line 127 | Line 222 | public class RecursiveActionTest extends
222		FibAction f = new FibAction(8);
223		f.quietlyInvoke();
224		assertEquals(21, f.result);
225	<	assertTrue(f.isDone());
131	<	assertFalse(f.isCancelled());
132	<	assertFalse(f.isCompletedAbnormally());
133	<	assertNull(f.getRawResult());
225	>	checkCompletedNormally(f);
226		}};
227		testInvokeOnPool(mainPool(), a);
228		}
#	Line 145 | Line 237 | public class RecursiveActionTest extends
237		assertSame(f, f.fork());
238		assertNull(f.join());
239		assertEquals(21, f.result);
240	<	assertTrue(f.isDone());
149	<	assertNull(f.getRawResult());
240	>	checkCompletedNormally(f);
241		}};
242		testInvokeOnPool(mainPool(), a);
243		}
#	Line 161 | Line 252 | public class RecursiveActionTest extends
252		assertSame(f, f.fork());
253		assertNull(f.get());
254		assertEquals(21, f.result);
255	<	assertTrue(f.isDone());
255	>	checkCompletedNormally(f);
256		}};
257		testInvokeOnPool(mainPool(), a);
258		}
#	Line 174 | Line 265 | public class RecursiveActionTest extends
265		public void realCompute() throws Exception {
266		FibAction f = new FibAction(8);
267		assertSame(f, f.fork());
268	<	assertNull(f.get(5L, TimeUnit.SECONDS));
268	>	assertNull(f.get(5L, SECONDS));
269		assertEquals(21, f.result);
270	<	assertTrue(f.isDone());
270	>	checkCompletedNormally(f);
271		}};
272		testInvokeOnPool(mainPool(), a);
273		}
#	Line 207 | Line 298 | public class RecursiveActionTest extends
298		assertSame(f, f.fork());
299		f.quietlyJoin();
300		assertEquals(21, f.result);
301	<	assertTrue(f.isDone());
301	>	checkCompletedNormally(f);
302		}};
303		testInvokeOnPool(mainPool(), a);
304		}
#	Line 224 | Line 315 | public class RecursiveActionTest extends
315		assertSame(f, f.fork());
316		f.helpQuiesce();
317		assertEquals(21, f.result);
227	–	assertTrue(f.isDone());
318		assertEquals(0, getQueuedTaskCount());
319	+	checkCompletedNormally(f);
320		}};
321		testInvokeOnPool(mainPool(), a);
322		}
#	Line 241 | Line 332 | public class RecursiveActionTest extends
332		try {
333		f.invoke();
334		shouldThrow();
335	<	} catch (FJException success) {}
335	>	} catch (FJException success) {
336	>	checkTaskThrew(f, success);
337	>	}
338		}};
339		testInvokeOnPool(mainPool(), a);
340		}
#	Line 254 | Line 347 | public class RecursiveActionTest extends
347		public void realCompute() {
348		FailingFibAction f = new FailingFibAction(8);
349		f.quietlyInvoke();
350	<	assertTrue(f.isDone());
350	>	assertTrue(f.getException() instanceof FJException);
351	>	checkTaskThrew(f, f.getException());
352		}};
353		testInvokeOnPool(mainPool(), a);
354		}
#	Line 270 | Line 364 | public class RecursiveActionTest extends
364		try {
365		f.join();
366		shouldThrow();
367	<	} catch (FJException success) {}
367	>	} catch (FJException success) {
368	>	checkTaskThrew(f, success);
369	>	}
370		}};
371		testInvokeOnPool(mainPool(), a);
372		}
#	Line 286 | Line 382 | public class RecursiveActionTest extends
382		try {
383		f.get();
384		shouldThrow();
385	<	} catch (ExecutionException success) {}
385	>	} catch (ExecutionException success) {
386	>	checkTaskThrew(f, success.getCause());
387	>	}
388		}};
389		testInvokeOnPool(mainPool(), a);
390		}
#	Line 302 | Line 400 | public class RecursiveActionTest extends
400		try {
401		f.get(5L, TimeUnit.SECONDS);
402		shouldThrow();
403	<	} catch (ExecutionException success) {}
403	>	} catch (ExecutionException success) {
404	>	checkTaskThrew(f, success.getCause());
405	>	}
406		}};
407		testInvokeOnPool(mainPool(), a);
408		}
#	Line 316 | Line 416 | public class RecursiveActionTest extends
416		FailingFibAction f = new FailingFibAction(8);
417		assertSame(f, f.fork());
418		f.quietlyJoin();
319	–	assertTrue(f.isDone());
320	–	assertTrue(f.isCompletedAbnormally());
419		assertTrue(f.getException() instanceof FJException);
420	+	checkTaskThrew(f, f.getException());
421		}};
422		testInvokeOnPool(mainPool(), a);
423		}
#	Line 334 | Line 433 | public class RecursiveActionTest extends
433		try {
434		f.invoke();
435		shouldThrow();
436	<	} catch (CancellationException success) {}
436	>	} catch (CancellationException success) {
437	>	checkCancelled(f);
438	>	}
439		}};
440		testInvokeOnPool(mainPool(), a);
441		}
#	Line 351 | Line 452 | public class RecursiveActionTest extends
452		try {
453		f.join();
454		shouldThrow();
455	<	} catch (CancellationException success) {}
455	>	} catch (CancellationException success) {
456	>	checkCancelled(f);
457	>	}
458		}};
459		testInvokeOnPool(mainPool(), a);
460		}
#	Line 368 | Line 471 | public class RecursiveActionTest extends
471		try {
472		f.get();
473		shouldThrow();
474	<	} catch (CancellationException success) {}
474	>	} catch (CancellationException success) {
475	>	checkCancelled(f);
476	>	}
477		}};
478		testInvokeOnPool(mainPool(), a);
479		}
#	Line 383 | Line 488 | public class RecursiveActionTest extends
488		assertTrue(f.cancel(true));
489		assertSame(f, f.fork());
490		try {
491	<	f.get(5L, TimeUnit.SECONDS);
491	>	f.get(5L, SECONDS);
492		shouldThrow();
493	<	} catch (CancellationException success) {}
493	>	} catch (CancellationException success) {
494	>	checkCancelled(f);
495	>	}
496		}};
497		testInvokeOnPool(mainPool(), a);
498		}
#	Line 400 | Line 507 | public class RecursiveActionTest extends
507		assertTrue(f.cancel(true));
508		assertSame(f, f.fork());
509		f.quietlyJoin();
510	<	assertTrue(f.isDone());
404	<	assertTrue(f.isCompletedAbnormally());
405	<	assertTrue(f.isCancelled());
406	<	assertTrue(f.getException() instanceof CancellationException);
510	>	checkCancelled(f);
511		}};
512		testInvokeOnPool(mainPool(), a);
513		}
#	Line 476 | Line 580 | public class RecursiveActionTest extends
580		public void realCompute() {
581		ForkJoinWorkerThread w =
582		(ForkJoinWorkerThread)(Thread.currentThread());
583	<	int idx = w.getPoolIndex();
584	<	assertTrue(idx >= 0);
481	<	assertTrue(idx < mainPool.getPoolSize());
583	>	assertTrue(w.getPoolIndex() >= 0);
584	>	assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
585		}};
586		testInvokeOnPool(mainPool, a);
587		}
#	Line 502 | Line 605 | public class RecursiveActionTest extends
605		RecursiveAction a = new CheckedRecursiveAction() {
606		public void realCompute() {
607		FibAction f = new FibAction(8);
608	<	assertNull(f.invoke());
609	<	assertEquals(21, f.result);
610	<	assertTrue(f.isDone());
611	<	assertFalse(f.isCancelled());
612	<	assertFalse(f.isCompletedAbnormally());
613	<	f.reinitialize();
614	<	assertNull(f.invoke());
615	<	assertEquals(21, f.result);
608	>	checkNotDone(f);
609	>
610	>	for (int i = 0; i < 3; i++) {
611	>	assertNull(f.invoke());
612	>	assertEquals(21, f.result);
613	>	checkCompletedNormally(f);
614	>	f.reinitialize();
615	>	checkNotDone(f);
616	>	}
617		}};
618		testInvokeOnPool(mainPool(), a);
619		}
#	Line 525 | Line 629 | public class RecursiveActionTest extends
629		try {
630		f.invoke();
631		shouldThrow();
632	<	} catch (FJException success) {}
632	>	} catch (FJException success) {
633	>	checkTaskThrew(f, success);
634	>	}
635		}};
636		testInvokeOnPool(mainPool(), a);
637		}
#	Line 539 | Line 645 | public class RecursiveActionTest extends
645		FibAction f = new FibAction(8);
646		f.complete(null);
647		assertNull(f.invoke());
542	–	assertTrue(f.isDone());
648		assertEquals(0, f.result);
649	+	checkCompletedNormally(f);
650		}};
651		testInvokeOnPool(mainPool(), a);
652		}
#	Line 554 | Line 660 | public class RecursiveActionTest extends
660		FibAction f = new FibAction(8);
661		FibAction g = new FibAction(9);
662		invokeAll(f, g);
663	<	assertTrue(f.isDone());
663	>	checkCompletedNormally(f);
664		assertEquals(21, f.result);
665	<	assertTrue(g.isDone());
665	>	checkCompletedNormally(g);
666		assertEquals(34, g.result);
667		}};
668		testInvokeOnPool(mainPool(), a);
#	Line 570 | Line 676 | public class RecursiveActionTest extends
676		public void realCompute() {
677		FibAction f = new FibAction(8);
678		invokeAll(f);
679	<	assertTrue(f.isDone());
679	>	checkCompletedNormally(f);
680		assertEquals(21, f.result);
681		}};
682		testInvokeOnPool(mainPool(), a);
#	Line 586 | Line 692 | public class RecursiveActionTest extends
692		FibAction g = new FibAction(9);
693		FibAction h = new FibAction(7);
694		invokeAll(f, g, h);
695	<	assertTrue(f.isDone());
695	>	checkCompletedNormally(f);
696		assertEquals(21, f.result);
697	<	assertTrue(g.isDone());
697	>	checkCompletedNormally(g);
698		assertEquals(34, g.result);
699	<	assertTrue(h.isDone());
699	>	checkCompletedNormally(g);
700		assertEquals(13, h.result);
701		}};
702		testInvokeOnPool(mainPool(), a);
#	Line 610 | Line 716 | public class RecursiveActionTest extends
716		set.add(g);
717		set.add(h);
718		invokeAll(set);
719	<	assertTrue(f.isDone());
719	>	checkCompletedNormally(f);
720		assertEquals(21, f.result);
721	<	assertTrue(g.isDone());
721	>	checkCompletedNormally(g);
722		assertEquals(34, g.result);
723	<	assertTrue(h.isDone());
723	>	checkCompletedNormally(g);
724		assertEquals(13, h.result);
725		}};
726		testInvokeOnPool(mainPool(), a);
#	Line 649 | Line 755 | public class RecursiveActionTest extends
755		try {
756		invokeAll(f, g);
757		shouldThrow();
758	<	} catch (FJException success) {}
758	>	} catch (FJException success) {
759	>	checkTaskThrew(g, success);
760	>	}
761		}};
762		testInvokeOnPool(mainPool(), a);
763		}
#	Line 664 | Line 772 | public class RecursiveActionTest extends
772		try {
773		invokeAll(g);
774		shouldThrow();
775	<	} catch (FJException success) {}
775	>	} catch (FJException success) {
776	>	checkTaskThrew(g, success);
777	>	}
778		}};
779		testInvokeOnPool(mainPool(), a);
780		}
#	Line 681 | Line 791 | public class RecursiveActionTest extends
791		try {
792		invokeAll(f, g, h);
793		shouldThrow();
794	<	} catch (FJException success) {}
794	>	} catch (FJException success) {
795	>	checkTaskThrew(g, success);
796	>	}
797		}};
798		testInvokeOnPool(mainPool(), a);
799		}
#	Line 702 | Line 814 | public class RecursiveActionTest extends
814		try {
815		invokeAll(set);
816		shouldThrow();
817	<	} catch (FJException success) {}
817	>	} catch (FJException success) {
818	>	checkTaskThrew(f, success);
819	>	}
820		}};
821		testInvokeOnPool(mainPool(), a);
822		}
#	Line 720 | Line 834 | public class RecursiveActionTest extends
834		assertSame(f, f.fork());
835		assertTrue(f.tryUnfork());
836		helpQuiesce();
837	<	assertFalse(f.isDone());
838	<	assertTrue(g.isDone());
837	>	checkNotDone(f);
838	>	checkCompletedNormally(g);
839		}};
840		testInvokeOnPool(singletonPool(), a);
841		}
#	Line 741 | Line 855 | public class RecursiveActionTest extends
855		assertSame(f, f.fork());
856		assertTrue(getSurplusQueuedTaskCount() > 0);
857		helpQuiesce();
858	+	checkCompletedNormally(f);
859	+	checkCompletedNormally(g);
860	+	checkCompletedNormally(h);
861		}};
862		testInvokeOnPool(singletonPool(), a);
863		}
#	Line 757 | Line 874 | public class RecursiveActionTest extends
874		assertSame(f, f.fork());
875		assertSame(f, peekNextLocalTask());
876		assertNull(f.join());
877	<	assertTrue(f.isDone());
877	>	checkCompletedNormally(f);
878		helpQuiesce();
879	+	checkCompletedNormally(f);
880	+	checkCompletedNormally(g);
881		}};
882		testInvokeOnPool(singletonPool(), a);
883		}
#	Line 776 | Line 895 | public class RecursiveActionTest extends
895		assertSame(f, f.fork());
896		assertSame(f, pollNextLocalTask());
897		helpQuiesce();
898	<	assertFalse(f.isDone());
898	>	checkNotDone(f);
899	>	checkCompletedNormally(g);
900		}};
901		testInvokeOnPool(singletonPool(), a);
902		}
903
904		/**
905	<	* pollTask returns an unexecuted task
786	<	* without executing it
905	>	* pollTask returns an unexecuted task without executing it
906		*/
907		public void testPollTask() {
908		RecursiveAction a = new CheckedRecursiveAction() {
#	Line 794 | Line 913 | public class RecursiveActionTest extends
913		assertSame(f, f.fork());
914		assertSame(f, pollTask());
915		helpQuiesce();
916	<	assertFalse(f.isDone());
917	<	assertTrue(g.isDone());
916	>	checkNotDone(f);
917	>	checkCompletedNormally(g);
918		}};
919		testInvokeOnPool(singletonPool(), a);
920		}
#	Line 813 | Line 932 | public class RecursiveActionTest extends
932		assertSame(g, peekNextLocalTask());
933		assertNull(f.join());
934		helpQuiesce();
935	<	assertTrue(f.isDone());
935	>	checkCompletedNormally(f);
936	>	checkCompletedNormally(g);
937		}};
938		testInvokeOnPool(asyncSingletonPool(), a);
939		}
940
941		/**
942	<	* pollNextLocalTask returns least recent unexecuted task
943	<	* without executing it, in async mode
942	>	* pollNextLocalTask returns least recent unexecuted task without
943	>	* executing it, in async mode
944		*/
945		public void testPollNextLocalTaskAsync() {
946		RecursiveAction a = new CheckedRecursiveAction() {
#	Line 831 | Line 951 | public class RecursiveActionTest extends
951		assertSame(f, f.fork());
952		assertSame(g, pollNextLocalTask());
953		helpQuiesce();
954	<	assertTrue(f.isDone());
955	<	assertFalse(g.isDone());
954	>	checkCompletedNormally(f);
955	>	checkNotDone(g);
956		}};
957		testInvokeOnPool(asyncSingletonPool(), a);
958		}
959
960		/**
961	<	* pollTask returns an unexecuted task
962	<	* without executing it, in async mode
961	>	* pollTask returns an unexecuted task without executing it, in
962	>	* async mode
963		*/
964		public void testPollTaskAsync() {
965		RecursiveAction a = new CheckedRecursiveAction() {
#	Line 850 | Line 970 | public class RecursiveActionTest extends
970		assertSame(f, f.fork());
971		assertSame(g, pollTask());
972		helpQuiesce();
973	<	assertTrue(f.isDone());
974	<	assertFalse(g.isDone());
973	>	checkCompletedNormally(f);
974	>	checkNotDone(g);
975		}};
976		testInvokeOnPool(asyncSingletonPool(), a);
977		}

Diff Legend

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