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.35 by jsr166, Sat Jun 25 06:54:53 2011 UTC vs.
Revision 1.55 by jsr166, Sun Jul 22 21:09:02 2018 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9	>	import java.util.Arrays;
10	>	import java.util.HashSet;
11		import java.util.concurrent.CancellationException;
9	–	import java.util.concurrent.SynchronousQueue;
12		import java.util.concurrent.ExecutionException;
13		import java.util.concurrent.ForkJoinPool;
14		import java.util.concurrent.ForkJoinTask;
15		import java.util.concurrent.ForkJoinWorkerThread;
16		import java.util.concurrent.RecursiveAction;
17	+	import java.util.concurrent.SynchronousQueue;
18		import java.util.concurrent.ThreadLocalRandom;
16	–	import java.util.concurrent.TimeUnit;
19		import java.util.concurrent.TimeoutException;
20	<	import static java.util.concurrent.TimeUnit.SECONDS;
21	<	import java.util.Arrays;
22	<	import java.util.HashSet;
20	>
21	>	import junit.framework.Test;
22	>	import junit.framework.TestSuite;
23
24		public class RecursiveActionTest extends JSR166TestCase {
25
26		public static void main(String[] args) {
27	<	junit.textui.TestRunner.run(suite());
27	>	main(suite(), args);
28		}
29
30		public static Test suite() {
#	Line 44 | Line 46 | public class RecursiveActionTest extends
46		}
47
48		private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
49	<	try {
49	>	try (PoolCleaner cleaner = cleaner(pool)) {
50		checkNotDone(a);
51
52		assertNull(pool.invoke(a));
53
54		checkCompletedNormally(a);
53	–	} finally {
54	–	joinPool(pool);
55		}
56		}
57
#	Line 73 | Line 73 | public class RecursiveActionTest extends
73
74		Thread.currentThread().interrupt();
75		try {
76	<	a.get(5L, SECONDS);
76	>	a.get(randomTimeout(), randomTimeUnit());
77		shouldThrow();
78		} catch (InterruptedException success) {
79		} catch (Throwable fail) { threadUnexpectedException(fail); }
80		}
81
82		try {
83	<	a.get(0L, SECONDS);
83	>	a.get(randomExpiredTimeout(), randomTimeUnit());
84		shouldThrow();
85		} catch (TimeoutException success) {
86		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 96 | Line 96 | public class RecursiveActionTest extends
96		assertNull(a.join());
97		assertFalse(a.cancel(false));
98		assertFalse(a.cancel(true));
99	+
100	+	Object v1 = null, v2 = null;
101		try {
102	<	assertNull(a.get());
103	<	} catch (Throwable fail) { threadUnexpectedException(fail); }
102	<	try {
103	<	assertNull(a.get(5L, SECONDS));
102	>	v1 = a.get();
103	>	v2 = a.get(randomTimeout(), randomTimeUnit());
104		} catch (Throwable fail) { threadUnexpectedException(fail); }
105	+	assertNull(v1);
106	+	assertNull(v2);
107		}
108
109		void checkCancelled(RecursiveAction a) {
#	Line 125 | Line 127 | public class RecursiveActionTest extends
127		} catch (Throwable fail) { threadUnexpectedException(fail); }
128
129		try {
130	<	a.get(5L, SECONDS);
130	>	a.get(randomTimeout(), randomTimeUnit());
131		shouldThrow();
132		} catch (CancellationException success) {
133		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 156 | Line 158 | public class RecursiveActionTest extends
158		} catch (Throwable fail) { threadUnexpectedException(fail); }
159
160		try {
161	<	a.get(5L, SECONDS);
161	>	a.get(randomTimeout(), randomTimeUnit());
162		shouldThrow();
163		} catch (ExecutionException success) {
164		assertSame(t.getClass(), success.getCause().getClass());
#	Line 168 | Line 170 | public class RecursiveActionTest extends
170		public FJException(Throwable cause) { super(cause); }
171		}
172
173	<	// A simple recursive action for testing
173	>	/** A simple recursive action for testing. */
174		final class FibAction extends CheckedRecursiveAction {
175		final int number;
176		int result;
177		FibAction(int n) { number = n; }
178	<	public void realCompute() {
178	>	protected void realCompute() {
179		int n = number;
180		if (n <= 1)
181		result = n;
#	Line 186 | Line 188 | public class RecursiveActionTest extends
188		}
189		}
190
191	<	// A recursive action failing in base case
191	>	/** A recursive action failing in base case. */
192		static final class FailingFibAction extends RecursiveAction {
193		final int number;
194		int result;
#	Line 211 | Line 213 | public class RecursiveActionTest extends
213		*/
214		public void testInvoke() {
215		RecursiveAction a = new CheckedRecursiveAction() {
216	<	public void realCompute() {
216	>	protected void realCompute() {
217		FibAction f = new FibAction(8);
218		assertNull(f.invoke());
219		assertEquals(21, f.result);
#	Line 227 | Line 229 | public class RecursiveActionTest extends
229		*/
230		public void testQuietlyInvoke() {
231		RecursiveAction a = new CheckedRecursiveAction() {
232	<	public void realCompute() {
232	>	protected void realCompute() {
233		FibAction f = new FibAction(8);
234		f.quietlyInvoke();
235		assertEquals(21, f.result);
#	Line 241 | Line 243 | public class RecursiveActionTest extends
243		*/
244		public void testForkJoin() {
245		RecursiveAction a = new CheckedRecursiveAction() {
246	<	public void realCompute() {
246	>	protected void realCompute() {
247		FibAction f = new FibAction(8);
248		assertSame(f, f.fork());
249		assertNull(f.join());
#	Line 256 | Line 258 | public class RecursiveActionTest extends
258		*/
259		public void testJoinIgnoresInterrupts() {
260		RecursiveAction a = new CheckedRecursiveAction() {
261	<	public void realCompute() {
261	>	protected void realCompute() {
262		FibAction f = new FibAction(8);
263	<	final Thread myself = Thread.currentThread();
263	>	final Thread currentThread = Thread.currentThread();
264
265		// test join()
266		assertSame(f, f.fork());
267	<	myself.interrupt();
266	<	assertTrue(myself.isInterrupted());
267	>	currentThread.interrupt();
268		assertNull(f.join());
269		Thread.interrupted();
270		assertEquals(21, f.result);
#	Line 272 | Line 273 | public class RecursiveActionTest extends
273		f = new FibAction(8);
274		f.cancel(true);
275		assertSame(f, f.fork());
276	<	myself.interrupt();
276	<	assertTrue(myself.isInterrupted());
276	>	currentThread.interrupt();
277		try {
278		f.join();
279		shouldThrow();
#	Line 285 | Line 285 | public class RecursiveActionTest extends
285		f = new FibAction(8);
286		f.completeExceptionally(new FJException());
287		assertSame(f, f.fork());
288	<	myself.interrupt();
289	<	assertTrue(myself.isInterrupted());
288	>	currentThread.interrupt();
289		try {
290		f.join();
291		shouldThrow();
#	Line 298 | Line 297 | public class RecursiveActionTest extends
297		// test quietlyJoin()
298		f = new FibAction(8);
299		assertSame(f, f.fork());
300	<	myself.interrupt();
302	<	assertTrue(myself.isInterrupted());
300	>	currentThread.interrupt();
301		f.quietlyJoin();
302		Thread.interrupted();
303		assertEquals(21, f.result);
#	Line 308 | Line 306 | public class RecursiveActionTest extends
306		f = new FibAction(8);
307		f.cancel(true);
308		assertSame(f, f.fork());
309	<	myself.interrupt();
312	<	assertTrue(myself.isInterrupted());
309	>	currentThread.interrupt();
310		f.quietlyJoin();
311		Thread.interrupted();
312		checkCancelled(f);
#	Line 317 | Line 314 | public class RecursiveActionTest extends
314		f = new FibAction(8);
315		f.completeExceptionally(new FJException());
316		assertSame(f, f.fork());
317	<	myself.interrupt();
321	<	assertTrue(myself.isInterrupted());
317	>	currentThread.interrupt();
318		f.quietlyJoin();
319		Thread.interrupted();
320		checkCompletedAbnormally(f, f.getException());
#	Line 333 | Line 329 | public class RecursiveActionTest extends
329		* succeeds in the presence of interrupts
330		*/
331		public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
332	<	final SynchronousQueue<FibAction[]> sq =
337	<	new SynchronousQueue<FibAction[]>();
332	>	final SynchronousQueue<FibAction[]> sq = new SynchronousQueue<>();
333		RecursiveAction a = new CheckedRecursiveAction() {
334	<	public void realCompute() throws InterruptedException {
334	>	protected void realCompute() throws InterruptedException {
335		FibAction[] fibActions = new FibAction[6];
336		for (int i = 0; i < fibActions.length; i++)
337		fibActions[i] = new FibAction(8);
#	Line 346 | Line 341 | public class RecursiveActionTest extends
341		fibActions[4].cancel(true);
342		fibActions[5].completeExceptionally(new FJException());
343
344	<	for (int i = 0; i < fibActions.length; i++)
345	<	fibActions[i].fork();
344	>	for (FibAction fibAction : fibActions)
345	>	fibAction.fork();
346
347		sq.put(fibActions);
348
#	Line 358 | Line 353 | public class RecursiveActionTest extends
353		public void realRun() throws InterruptedException {
354		FibAction[] fibActions = sq.take();
355		FibAction f;
356	<	final Thread myself = Thread.currentThread();
356	>	final Thread currentThread = Thread.currentThread();
357
358		// test join() ------------
359
360		f = fibActions[0];
361		assertFalse(ForkJoinTask.inForkJoinPool());
362	<	myself.interrupt();
368	<	assertTrue(myself.isInterrupted());
362	>	currentThread.interrupt();
363		assertNull(f.join());
364		assertTrue(Thread.interrupted());
365		assertEquals(21, f.result);
366		checkCompletedNormally(f);
367
368		f = fibActions[1];
369	<	myself.interrupt();
376	<	assertTrue(myself.isInterrupted());
369	>	currentThread.interrupt();
370		try {
371		f.join();
372		shouldThrow();
#	Line 383 | Line 376 | public class RecursiveActionTest extends
376		}
377
378		f = fibActions[2];
379	<	myself.interrupt();
387	<	assertTrue(myself.isInterrupted());
379	>	currentThread.interrupt();
380		try {
381		f.join();
382		shouldThrow();
#	Line 396 | Line 388 | public class RecursiveActionTest extends
388		// test quietlyJoin() ---------
389
390		f = fibActions[3];
391	<	myself.interrupt();
400	<	assertTrue(myself.isInterrupted());
391	>	currentThread.interrupt();
392		f.quietlyJoin();
393		assertTrue(Thread.interrupted());
394		assertEquals(21, f.result);
395		checkCompletedNormally(f);
396
397		f = fibActions[4];
398	<	myself.interrupt();
408	<	assertTrue(myself.isInterrupted());
398	>	currentThread.interrupt();
399		f.quietlyJoin();
400		assertTrue(Thread.interrupted());
401		checkCancelled(f);
402
403		f = fibActions[5];
404	<	myself.interrupt();
415	<	assertTrue(myself.isInterrupted());
404	>	currentThread.interrupt();
405		f.quietlyJoin();
406		assertTrue(Thread.interrupted());
407		assertTrue(f.getException() instanceof FJException);
#	Line 423 | Line 412 | public class RecursiveActionTest extends
412
413		t = newStartedThread(r);
414		testInvokeOnPool(mainPool(), a);
415	<	awaitTermination(t, LONG_DELAY_MS);
415	>	awaitTermination(t);
416
417		a.reinitialize();
418		t = newStartedThread(r);
419		testInvokeOnPool(singletonPool(), a);
420	<	awaitTermination(t, LONG_DELAY_MS);
420	>	awaitTermination(t);
421		}
422
423		/**
#	Line 436 | Line 425 | public class RecursiveActionTest extends
425		*/
426		public void testForkGet() {
427		RecursiveAction a = new CheckedRecursiveAction() {
428	<	public void realCompute() throws Exception {
428	>	protected void realCompute() throws Exception {
429		FibAction f = new FibAction(8);
430		assertSame(f, f.fork());
431		assertNull(f.get());
#	Line 451 | Line 440 | public class RecursiveActionTest extends
440		*/
441		public void testForkTimedGet() {
442		RecursiveAction a = new CheckedRecursiveAction() {
443	<	public void realCompute() throws Exception {
443	>	protected void realCompute() throws Exception {
444		FibAction f = new FibAction(8);
445		assertSame(f, f.fork());
446	<	assertNull(f.get(5L, SECONDS));
446	>	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
447		assertEquals(21, f.result);
448		checkCompletedNormally(f);
449		}};
#	Line 466 | Line 455 | public class RecursiveActionTest extends
455		*/
456		public void testForkTimedGetNPE() {
457		RecursiveAction a = new CheckedRecursiveAction() {
458	<	public void realCompute() throws Exception {
458	>	protected void realCompute() throws Exception {
459		FibAction f = new FibAction(8);
460		assertSame(f, f.fork());
461		try {
462	<	f.get(5L, null);
462	>	f.get(randomTimeout(), null);
463		shouldThrow();
464		} catch (NullPointerException success) {}
465		}};
#	Line 482 | Line 471 | public class RecursiveActionTest extends
471		*/
472		public void testForkQuietlyJoin() {
473		RecursiveAction a = new CheckedRecursiveAction() {
474	<	public void realCompute() {
474	>	protected void realCompute() {
475		FibAction f = new FibAction(8);
476		assertSame(f, f.fork());
477		f.quietlyJoin();
#	Line 498 | Line 487 | public class RecursiveActionTest extends
487		*/
488		public void testForkHelpQuiesce() {
489		RecursiveAction a = new CheckedRecursiveAction() {
490	<	public void realCompute() {
490	>	protected void realCompute() {
491		FibAction f = new FibAction(8);
492		assertSame(f, f.fork());
493		helpQuiesce();
494	+	while (!f.isDone()) // wait out race
495	+	;
496		assertEquals(21, f.result);
497		assertEquals(0, getQueuedTaskCount());
498		checkCompletedNormally(f);
#	Line 514 | Line 505 | public class RecursiveActionTest extends
505		*/
506		public void testAbnormalInvoke() {
507		RecursiveAction a = new CheckedRecursiveAction() {
508	<	public void realCompute() {
508	>	protected void realCompute() {
509		FailingFibAction f = new FailingFibAction(8);
510		try {
511		f.invoke();
#	Line 531 | Line 522 | public class RecursiveActionTest extends
522		*/
523		public void testAbnormalQuietlyInvoke() {
524		RecursiveAction a = new CheckedRecursiveAction() {
525	<	public void realCompute() {
525	>	protected void realCompute() {
526		FailingFibAction f = new FailingFibAction(8);
527		f.quietlyInvoke();
528		assertTrue(f.getException() instanceof FJException);
#	Line 545 | Line 536 | public class RecursiveActionTest extends
536		*/
537		public void testAbnormalForkJoin() {
538		RecursiveAction a = new CheckedRecursiveAction() {
539	<	public void realCompute() {
539	>	protected void realCompute() {
540		FailingFibAction f = new FailingFibAction(8);
541		assertSame(f, f.fork());
542		try {
#	Line 563 | Line 554 | public class RecursiveActionTest extends
554		*/
555		public void testAbnormalForkGet() {
556		RecursiveAction a = new CheckedRecursiveAction() {
557	<	public void realCompute() throws Exception {
557	>	protected void realCompute() throws Exception {
558		FailingFibAction f = new FailingFibAction(8);
559		assertSame(f, f.fork());
560		try {
#	Line 583 | Line 574 | public class RecursiveActionTest extends
574		*/
575		public void testAbnormalForkTimedGet() {
576		RecursiveAction a = new CheckedRecursiveAction() {
577	<	public void realCompute() throws Exception {
577	>	protected void realCompute() throws Exception {
578		FailingFibAction f = new FailingFibAction(8);
579		assertSame(f, f.fork());
580		try {
581	<	f.get(5L, TimeUnit.SECONDS);
581	>	f.get(LONG_DELAY_MS, MILLISECONDS);
582		shouldThrow();
583		} catch (ExecutionException success) {
584		Throwable cause = success.getCause();
#	Line 603 | Line 594 | public class RecursiveActionTest extends
594		*/
595		public void testAbnormalForkQuietlyJoin() {
596		RecursiveAction a = new CheckedRecursiveAction() {
597	<	public void realCompute() {
597	>	protected void realCompute() {
598		FailingFibAction f = new FailingFibAction(8);
599		assertSame(f, f.fork());
600		f.quietlyJoin();
#	Line 618 | Line 609 | public class RecursiveActionTest extends
609		*/
610		public void testCancelledInvoke() {
611		RecursiveAction a = new CheckedRecursiveAction() {
612	<	public void realCompute() {
612	>	protected void realCompute() {
613		FibAction f = new FibAction(8);
614		assertTrue(f.cancel(true));
615		try {
#	Line 636 | Line 627 | public class RecursiveActionTest extends
627		*/
628		public void testCancelledForkJoin() {
629		RecursiveAction a = new CheckedRecursiveAction() {
630	<	public void realCompute() {
630	>	protected void realCompute() {
631		FibAction f = new FibAction(8);
632		assertTrue(f.cancel(true));
633		assertSame(f, f.fork());
#	Line 655 | Line 646 | public class RecursiveActionTest extends
646		*/
647		public void testCancelledForkGet() {
648		RecursiveAction a = new CheckedRecursiveAction() {
649	<	public void realCompute() throws Exception {
649	>	protected void realCompute() throws Exception {
650		FibAction f = new FibAction(8);
651		assertTrue(f.cancel(true));
652		assertSame(f, f.fork());
#	Line 674 | Line 665 | public class RecursiveActionTest extends
665		*/
666		public void testCancelledForkTimedGet() {
667		RecursiveAction a = new CheckedRecursiveAction() {
668	<	public void realCompute() throws Exception {
668	>	protected void realCompute() throws Exception {
669		FibAction f = new FibAction(8);
670		assertTrue(f.cancel(true));
671		assertSame(f, f.fork());
672		try {
673	<	f.get(5L, SECONDS);
673	>	f.get(LONG_DELAY_MS, MILLISECONDS);
674		shouldThrow();
675		} catch (CancellationException success) {
676		checkCancelled(f);
#	Line 693 | Line 684 | public class RecursiveActionTest extends
684		*/
685		public void testCancelledForkQuietlyJoin() {
686		RecursiveAction a = new CheckedRecursiveAction() {
687	<	public void realCompute() {
687	>	protected void realCompute() {
688		FibAction f = new FibAction(8);
689		assertTrue(f.cancel(true));
690		assertSame(f, f.fork());
#	Line 709 | Line 700 | public class RecursiveActionTest extends
700		public void testGetPool() {
701		final ForkJoinPool mainPool = mainPool();
702		RecursiveAction a = new CheckedRecursiveAction() {
703	<	public void realCompute() {
703	>	protected void realCompute() {
704		assertSame(mainPool, getPool());
705		}};
706		testInvokeOnPool(mainPool, a);
#	Line 720 | Line 711 | public class RecursiveActionTest extends
711		*/
712		public void testGetPool2() {
713		RecursiveAction a = new CheckedRecursiveAction() {
714	<	public void realCompute() {
714	>	protected void realCompute() {
715		assertNull(getPool());
716		}};
717		assertNull(a.invoke());
#	Line 731 | Line 722 | public class RecursiveActionTest extends
722		*/
723		public void testInForkJoinPool() {
724		RecursiveAction a = new CheckedRecursiveAction() {
725	<	public void realCompute() {
725	>	protected void realCompute() {
726		assertTrue(inForkJoinPool());
727		}};
728		testInvokeOnPool(mainPool(), a);
#	Line 742 | Line 733 | public class RecursiveActionTest extends
733		*/
734		public void testInForkJoinPool2() {
735		RecursiveAction a = new CheckedRecursiveAction() {
736	<	public void realCompute() {
736	>	protected void realCompute() {
737		assertFalse(inForkJoinPool());
738		}};
739		assertNull(a.invoke());
#	Line 754 | Line 745 | public class RecursiveActionTest extends
745		public void testWorkerGetPool() {
746		final ForkJoinPool mainPool = mainPool();
747		RecursiveAction a = new CheckedRecursiveAction() {
748	<	public void realCompute() {
748	>	protected void realCompute() {
749		ForkJoinWorkerThread w =
750		(ForkJoinWorkerThread) Thread.currentThread();
751		assertSame(mainPool, w.getPool());
#	Line 768 | Line 759 | public class RecursiveActionTest extends
759		public void testWorkerGetPoolIndex() {
760		final ForkJoinPool mainPool = mainPool();
761		RecursiveAction a = new CheckedRecursiveAction() {
762	<	public void realCompute() {
762	>	protected void realCompute() {
763		ForkJoinWorkerThread w =
764		(ForkJoinWorkerThread) Thread.currentThread();
765		assertTrue(w.getPoolIndex() >= 0);
#	Line 783 | Line 774 | public class RecursiveActionTest extends
774		*/
775		public void testSetRawResult() {
776		RecursiveAction a = new CheckedRecursiveAction() {
777	<	public void realCompute() {
777	>	protected void realCompute() {
778		setRawResult(null);
779		assertNull(getRawResult());
780		}};
#	Line 795 | Line 786 | public class RecursiveActionTest extends
786		*/
787		public void testReinitialize() {
788		RecursiveAction a = new CheckedRecursiveAction() {
789	<	public void realCompute() {
789	>	protected void realCompute() {
790		FibAction f = new FibAction(8);
791		checkNotDone(f);
792
#	Line 815 | Line 806 | public class RecursiveActionTest extends
806		*/
807		public void testReinitializeAbnormal() {
808		RecursiveAction a = new CheckedRecursiveAction() {
809	<	public void realCompute() {
809	>	protected void realCompute() {
810		FailingFibAction f = new FailingFibAction(8);
811		checkNotDone(f);
812
#	Line 838 | Line 829 | public class RecursiveActionTest extends
829		*/
830		public void testCompleteExceptionally() {
831		RecursiveAction a = new CheckedRecursiveAction() {
832	<	public void realCompute() {
832	>	protected void realCompute() {
833		FibAction f = new FibAction(8);
834		f.completeExceptionally(new FJException());
835		try {
#	Line 856 | Line 847 | public class RecursiveActionTest extends
847		*/
848		public void testComplete() {
849		RecursiveAction a = new CheckedRecursiveAction() {
850	<	public void realCompute() {
850	>	protected void realCompute() {
851		FibAction f = new FibAction(8);
852		f.complete(null);
853		assertNull(f.invoke());
#	Line 871 | Line 862 | public class RecursiveActionTest extends
862		*/
863		public void testInvokeAll2() {
864		RecursiveAction a = new CheckedRecursiveAction() {
865	<	public void realCompute() {
865	>	protected void realCompute() {
866		FibAction f = new FibAction(8);
867		FibAction g = new FibAction(9);
868		invokeAll(f, g);
#	Line 888 | Line 879 | public class RecursiveActionTest extends
879		*/
880		public void testInvokeAll1() {
881		RecursiveAction a = new CheckedRecursiveAction() {
882	<	public void realCompute() {
882	>	protected void realCompute() {
883		FibAction f = new FibAction(8);
884		invokeAll(f);
885		checkCompletedNormally(f);
#	Line 902 | Line 893 | public class RecursiveActionTest extends
893		*/
894		public void testInvokeAll3() {
895		RecursiveAction a = new CheckedRecursiveAction() {
896	<	public void realCompute() {
896	>	protected void realCompute() {
897		FibAction f = new FibAction(8);
898		FibAction g = new FibAction(9);
899		FibAction h = new FibAction(7);
#	Line 925 | Line 916 | public class RecursiveActionTest extends
916		*/
917		public void testInvokeAllCollection() {
918		RecursiveAction a = new CheckedRecursiveAction() {
919	<	public void realCompute() {
919	>	protected void realCompute() {
920		FibAction f = new FibAction(8);
921		FibAction g = new FibAction(9);
922		FibAction h = new FibAction(7);
#	Line 952 | Line 943 | public class RecursiveActionTest extends
943		*/
944		public void testInvokeAllNPE() {
945		RecursiveAction a = new CheckedRecursiveAction() {
946	<	public void realCompute() {
946	>	protected void realCompute() {
947		FibAction f = new FibAction(8);
948		FibAction g = new FibAction(9);
949		FibAction h = null;
#	Line 969 | Line 960 | public class RecursiveActionTest extends
960		*/
961		public void testAbnormalInvokeAll2() {
962		RecursiveAction a = new CheckedRecursiveAction() {
963	<	public void realCompute() {
963	>	protected void realCompute() {
964		FibAction f = new FibAction(8);
965		FailingFibAction g = new FailingFibAction(9);
966		try {
#	Line 987 | Line 978 | public class RecursiveActionTest extends
978		*/
979		public void testAbnormalInvokeAll1() {
980		RecursiveAction a = new CheckedRecursiveAction() {
981	<	public void realCompute() {
981	>	protected void realCompute() {
982		FailingFibAction g = new FailingFibAction(9);
983		try {
984		invokeAll(g);
#	Line 1004 | Line 995 | public class RecursiveActionTest extends
995		*/
996		public void testAbnormalInvokeAll3() {
997		RecursiveAction a = new CheckedRecursiveAction() {
998	<	public void realCompute() {
998	>	protected void realCompute() {
999		FibAction f = new FibAction(8);
1000		FailingFibAction g = new FailingFibAction(9);
1001		FibAction h = new FibAction(7);
#	Line 1023 | Line 1014 | public class RecursiveActionTest extends
1014		*/
1015		public void testAbnormalInvokeAllCollection() {
1016		RecursiveAction a = new CheckedRecursiveAction() {
1017	<	public void realCompute() {
1017	>	protected void realCompute() {
1018		FailingFibAction f = new FailingFibAction(8);
1019		FibAction g = new FibAction(9);
1020		FibAction h = new FibAction(7);
#	Line 1047 | Line 1038 | public class RecursiveActionTest extends
1038		*/
1039		public void testTryUnfork() {
1040		RecursiveAction a = new CheckedRecursiveAction() {
1041	<	public void realCompute() {
1041	>	protected void realCompute() {
1042		FibAction g = new FibAction(9);
1043		assertSame(g, g.fork());
1044		FibAction f = new FibAction(8);
#	Line 1066 | Line 1057 | public class RecursiveActionTest extends
1057		*/
1058		public void testGetSurplusQueuedTaskCount() {
1059		RecursiveAction a = new CheckedRecursiveAction() {
1060	<	public void realCompute() {
1060	>	protected void realCompute() {
1061		FibAction h = new FibAction(7);
1062		assertSame(h, h.fork());
1063		FibAction g = new FibAction(9);
#	Line 1088 | Line 1079 | public class RecursiveActionTest extends
1079		*/
1080		public void testPeekNextLocalTask() {
1081		RecursiveAction a = new CheckedRecursiveAction() {
1082	<	public void realCompute() {
1082	>	protected void realCompute() {
1083		FibAction g = new FibAction(9);
1084		assertSame(g, g.fork());
1085		FibAction f = new FibAction(8);
#	Line 1109 | Line 1100 | public class RecursiveActionTest extends
1100		*/
1101		public void testPollNextLocalTask() {
1102		RecursiveAction a = new CheckedRecursiveAction() {
1103	<	public void realCompute() {
1103	>	protected void realCompute() {
1104		FibAction g = new FibAction(9);
1105		assertSame(g, g.fork());
1106		FibAction f = new FibAction(8);
#	Line 1127 | Line 1118 | public class RecursiveActionTest extends
1118		*/
1119		public void testPollTask() {
1120		RecursiveAction a = new CheckedRecursiveAction() {
1121	<	public void realCompute() {
1121	>	protected void realCompute() {
1122		FibAction g = new FibAction(9);
1123		assertSame(g, g.fork());
1124		FibAction f = new FibAction(8);
#	Line 1145 | Line 1136 | public class RecursiveActionTest extends
1136		*/
1137		public void testPeekNextLocalTaskAsync() {
1138		RecursiveAction a = new CheckedRecursiveAction() {
1139	<	public void realCompute() {
1139	>	protected void realCompute() {
1140		FibAction g = new FibAction(9);
1141		assertSame(g, g.fork());
1142		FibAction f = new FibAction(8);
#	Line 1165 | Line 1156 | public class RecursiveActionTest extends
1156		*/
1157		public void testPollNextLocalTaskAsync() {
1158		RecursiveAction a = new CheckedRecursiveAction() {
1159	<	public void realCompute() {
1159	>	protected void realCompute() {
1160		FibAction g = new FibAction(9);
1161		assertSame(g, g.fork());
1162		FibAction f = new FibAction(8);
#	Line 1184 | Line 1175 | public class RecursiveActionTest extends
1175		*/
1176		public void testPollTaskAsync() {
1177		RecursiveAction a = new CheckedRecursiveAction() {
1178	<	public void realCompute() {
1178	>	protected void realCompute() {
1179		FibAction g = new FibAction(9);
1180		assertSame(g, g.fork());
1181		FibAction f = new FibAction(8);
#	Line 1197 | Line 1188 | public class RecursiveActionTest extends
1188		testInvokeOnPool(asyncSingletonPool(), a);
1189		}
1190
1191	+	/** Demo from RecursiveAction javadoc */
1192		static class SortTask extends RecursiveAction {
1193		final long[] array; final int lo, hi;
1194		SortTask(long[] array, int lo, int hi) {
1195		this.array = array; this.lo = lo; this.hi = hi;
1196		}
1197	<	final static int THRESHOLD = 100;
1197	>	SortTask(long[] array) { this(array, 0, array.length); }
1198		protected void compute() {
1199		if (hi - lo < THRESHOLD)
1200	<	sequentiallySort(array, lo, hi);
1200	>	sortSequentially(lo, hi);
1201		else {
1202		int mid = (lo + hi) >>> 1;
1203		invokeAll(new SortTask(array, lo, mid),
1204		new SortTask(array, mid, hi));
1205	<	merge(array, lo, mid, hi);
1205	>	merge(lo, mid, hi);
1206		}
1207		}
1208	<	static void sequentiallySort(long[] array, int lo, int hi) {
1208	>	// implementation details follow:
1209	>	static final int THRESHOLD = 100;
1210	>	void sortSequentially(int lo, int hi) {
1211		Arrays.sort(array, lo, hi);
1212		}
1213	<	static void merge(long[] array, int lo, int mid, int hi) {
1214	<	int n = hi - lo;
1215	<	long[] buf = new long[n];
1216	<	int a = lo, b = mid;
1217	<	for (int i = 0; i < n; i++)
1224	<	buf[i] = (b == hi || (a < mid && array[a] < array[b])) ?
1225	<	array[a++] : array[b++];
1226	<	System.arraycopy(buf, 0, array, lo, n);
1213	>	void merge(int lo, int mid, int hi) {
1214	>	long[] buf = Arrays.copyOfRange(array, lo, mid);
1215	>	for (int i = 0, j = lo, k = mid; i < buf.length; j++)
1216	>	array[j] = (k == hi || buf[i] < array[k]) ?
1217	>	buf[i++] : array[k++];
1218		}
1219		}
1220
#	Line 1236 | Line 1227 | public class RecursiveActionTest extends
1227		for (int i = 0; i < array.length; i++)
1228		array[i] = rnd.nextLong();
1229		long[] arrayClone = array.clone();
1230	<	testInvokeOnPool(mainPool(),
1240	<	new SortTask(array, 0, array.length));
1230	>	testInvokeOnPool(mainPool(), new SortTask(array));
1231		Arrays.sort(arrayClone);
1232		assertTrue(Arrays.equals(array, arrayClone));
1233		}

Diff Legend

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