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.25 by jsr166, Tue Nov 23 06:33:26 2010 UTC vs.
Revision 1.49 by jsr166, Sat Mar 18 18:20:00 2017 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
7	>	import static java.util.concurrent.TimeUnit.SECONDS;
8	>
9	>	import java.util.Arrays;
10	>	import java.util.HashSet;
11		import java.util.concurrent.CancellationException;
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.TimeUnit;
17	>	import java.util.concurrent.SynchronousQueue;
18	>	import java.util.concurrent.ThreadLocalRandom;
19		import java.util.concurrent.TimeoutException;
20	<	import static java.util.concurrent.TimeUnit.SECONDS;
21	<	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 40 | 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);
49	–	} finally {
50	–	joinPool(pool);
55		}
56		}
57
#	Line 59 | Line 63 | public class RecursiveActionTest extends
63		assertNull(a.getException());
64		assertNull(a.getRawResult());
65
66	<	if (! (Thread.currentThread() instanceof ForkJoinWorkerThread)) {
66	>	if (! ForkJoinTask.inForkJoinPool()) {
67		Thread.currentThread().interrupt();
68		try {
69		a.get();
#	Line 132 | Line 136 | public class RecursiveActionTest extends
136		assertFalse(a.isCancelled());
137		assertFalse(a.isCompletedNormally());
138		assertTrue(a.isCompletedAbnormally());
139	<	assertSame(t, a.getException());
139	>	assertSame(t.getClass(), a.getException().getClass());
140		assertNull(a.getRawResult());
141		assertFalse(a.cancel(false));
142		assertFalse(a.cancel(true));
#	Line 141 | Line 145 | public class RecursiveActionTest extends
145		a.join();
146		shouldThrow();
147		} catch (Throwable expected) {
148	<	assertSame(t, expected);
148	>	assertSame(expected.getClass(), t.getClass());
149		}
150
151		try {
152		a.get();
153		shouldThrow();
154		} catch (ExecutionException success) {
155	<	assertSame(t, success.getCause());
155	>	assertSame(t.getClass(), success.getCause().getClass());
156		} catch (Throwable fail) { threadUnexpectedException(fail); }
157
158		try {
159		a.get(5L, SECONDS);
160		shouldThrow();
161		} catch (ExecutionException success) {
162	<	assertSame(t, success.getCause());
162	>	assertSame(t.getClass(), success.getCause().getClass());
163		} catch (Throwable fail) { threadUnexpectedException(fail); }
164		}
165
166	<	static final class FJException extends RuntimeException {
167	<	FJException() { super(); }
166	>	public static final class FJException extends RuntimeException {
167	>	public FJException() { super(); }
168	>	public FJException(Throwable cause) { super(cause); }
169		}
170
171	<	// A simple recursive action for testing
171	>	/** A simple recursive action for testing. */
172		final class FibAction extends CheckedRecursiveAction {
173		final int number;
174		int result;
175		FibAction(int n) { number = n; }
176	<	public void realCompute() {
176	>	protected void realCompute() {
177		int n = number;
178		if (n <= 1)
179		result = n;
#	Line 181 | Line 186 | public class RecursiveActionTest extends
186		}
187		}
188
189	<	// A recursive action failing in base case
189	>	/** A recursive action failing in base case. */
190		static final class FailingFibAction extends RecursiveAction {
191		final int number;
192		int result;
#	Line 206 | Line 211 | public class RecursiveActionTest extends
211		*/
212		public void testInvoke() {
213		RecursiveAction a = new CheckedRecursiveAction() {
214	<	public void realCompute() {
214	>	protected void realCompute() {
215		FibAction f = new FibAction(8);
216		assertNull(f.invoke());
217		assertEquals(21, f.result);
#	Line 222 | Line 227 | public class RecursiveActionTest extends
227		*/
228		public void testQuietlyInvoke() {
229		RecursiveAction a = new CheckedRecursiveAction() {
230	<	public void realCompute() {
230	>	protected void realCompute() {
231		FibAction f = new FibAction(8);
232		f.quietlyInvoke();
233		assertEquals(21, f.result);
#	Line 236 | Line 241 | public class RecursiveActionTest extends
241		*/
242		public void testForkJoin() {
243		RecursiveAction a = new CheckedRecursiveAction() {
244	<	public void realCompute() {
244	>	protected void realCompute() {
245		FibAction f = new FibAction(8);
246		assertSame(f, f.fork());
247		assertNull(f.join());
#	Line 251 | Line 256 | public class RecursiveActionTest extends
256		*/
257		public void testJoinIgnoresInterrupts() {
258		RecursiveAction a = new CheckedRecursiveAction() {
259	<	public void realCompute() {
259	>	protected void realCompute() {
260		FibAction f = new FibAction(8);
261	+	final Thread currentThread = Thread.currentThread();
262
263		// test join()
264		assertSame(f, f.fork());
265	<	Thread.currentThread().interrupt();
265	>	currentThread.interrupt();
266		assertNull(f.join());
267		Thread.interrupted();
268		assertEquals(21, f.result);
269		checkCompletedNormally(f);
270
271	<	f.reinitialize();
271	>	f = new FibAction(8);
272		f.cancel(true);
273		assertSame(f, f.fork());
274	<	Thread.currentThread().interrupt();
274	>	currentThread.interrupt();
275		try {
276		f.join();
277		shouldThrow();
#	Line 274 | Line 280 | public class RecursiveActionTest extends
280		checkCancelled(f);
281		}
282
283	<	f.reinitialize();
283	>	f = new FibAction(8);
284		f.completeExceptionally(new FJException());
285		assertSame(f, f.fork());
286	<	Thread.currentThread().interrupt();
286	>	currentThread.interrupt();
287		try {
288		f.join();
289		shouldThrow();
#	Line 287 | Line 293 | public class RecursiveActionTest extends
293		}
294
295		// test quietlyJoin()
296	<	f.reinitialize();
296	>	f = new FibAction(8);
297		assertSame(f, f.fork());
298	<	Thread.currentThread().interrupt();
298	>	currentThread.interrupt();
299		f.quietlyJoin();
300		Thread.interrupted();
301		assertEquals(21, f.result);
302		checkCompletedNormally(f);
303
304	<	f.reinitialize();
304	>	f = new FibAction(8);
305		f.cancel(true);
306		assertSame(f, f.fork());
307	<	Thread.currentThread().interrupt();
307	>	currentThread.interrupt();
308		f.quietlyJoin();
309		Thread.interrupted();
310		checkCancelled(f);
311
312	<	f.reinitialize();
312	>	f = new FibAction(8);
313		f.completeExceptionally(new FJException());
314		assertSame(f, f.fork());
315	<	Thread.currentThread().interrupt();
315	>	currentThread.interrupt();
316		f.quietlyJoin();
317		Thread.interrupted();
318		checkCompletedAbnormally(f, f.getException());
#	Line 317 | Line 323 | public class RecursiveActionTest extends
323		}
324
325		/**
326	+	* join/quietlyJoin of a forked task when not in ForkJoinPool
327	+	* succeeds in the presence of interrupts
328	+	*/
329	+	public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
330	+	final SynchronousQueue<FibAction[]> sq =
331	+	new SynchronousQueue<FibAction[]>();
332	+	RecursiveAction a = new CheckedRecursiveAction() {
333	+	protected void realCompute() throws InterruptedException {
334	+	FibAction[] fibActions = new FibAction[6];
335	+	for (int i = 0; i < fibActions.length; i++)
336	+	fibActions[i] = new FibAction(8);
337	+
338	+	fibActions[1].cancel(false);
339	+	fibActions[2].completeExceptionally(new FJException());
340	+	fibActions[4].cancel(true);
341	+	fibActions[5].completeExceptionally(new FJException());
342	+
343	+	for (int i = 0; i < fibActions.length; i++)
344	+	fibActions[i].fork();
345	+
346	+	sq.put(fibActions);
347	+
348	+	helpQuiesce();
349	+	}};
350	+
351	+	Runnable r = new CheckedRunnable() {
352	+	public void realRun() throws InterruptedException {
353	+	FibAction[] fibActions = sq.take();
354	+	FibAction f;
355	+	final Thread currentThread = Thread.currentThread();
356	+
357	+	// test join() ------------
358	+
359	+	f = fibActions[0];
360	+	assertFalse(ForkJoinTask.inForkJoinPool());
361	+	currentThread.interrupt();
362	+	assertNull(f.join());
363	+	assertTrue(Thread.interrupted());
364	+	assertEquals(21, f.result);
365	+	checkCompletedNormally(f);
366	+
367	+	f = fibActions[1];
368	+	currentThread.interrupt();
369	+	try {
370	+	f.join();
371	+	shouldThrow();
372	+	} catch (CancellationException success) {
373	+	assertTrue(Thread.interrupted());
374	+	checkCancelled(f);
375	+	}
376	+
377	+	f = fibActions[2];
378	+	currentThread.interrupt();
379	+	try {
380	+	f.join();
381	+	shouldThrow();
382	+	} catch (FJException success) {
383	+	assertTrue(Thread.interrupted());
384	+	checkCompletedAbnormally(f, success);
385	+	}
386	+
387	+	// test quietlyJoin() ---------
388	+
389	+	f = fibActions[3];
390	+	currentThread.interrupt();
391	+	f.quietlyJoin();
392	+	assertTrue(Thread.interrupted());
393	+	assertEquals(21, f.result);
394	+	checkCompletedNormally(f);
395	+
396	+	f = fibActions[4];
397	+	currentThread.interrupt();
398	+	f.quietlyJoin();
399	+	assertTrue(Thread.interrupted());
400	+	checkCancelled(f);
401	+
402	+	f = fibActions[5];
403	+	currentThread.interrupt();
404	+	f.quietlyJoin();
405	+	assertTrue(Thread.interrupted());
406	+	assertTrue(f.getException() instanceof FJException);
407	+	checkCompletedAbnormally(f, f.getException());
408	+	}};
409	+
410	+	Thread t;
411	+
412	+	t = newStartedThread(r);
413	+	testInvokeOnPool(mainPool(), a);
414	+	awaitTermination(t);
415	+
416	+	a.reinitialize();
417	+	t = newStartedThread(r);
418	+	testInvokeOnPool(singletonPool(), a);
419	+	awaitTermination(t);
420	+	}
421	+
422	+	/**
423		* get of a forked task returns when task completes
424		*/
425		public void testForkGet() {
426		RecursiveAction a = new CheckedRecursiveAction() {
427	<	public void realCompute() throws Exception {
427	>	protected void realCompute() throws Exception {
428		FibAction f = new FibAction(8);
429		assertSame(f, f.fork());
430		assertNull(f.get());
#	Line 336 | Line 439 | public class RecursiveActionTest extends
439		*/
440		public void testForkTimedGet() {
441		RecursiveAction a = new CheckedRecursiveAction() {
442	<	public void realCompute() throws Exception {
442	>	protected void realCompute() throws Exception {
443		FibAction f = new FibAction(8);
444		assertSame(f, f.fork());
445		assertNull(f.get(5L, SECONDS));
#	Line 351 | Line 454 | public class RecursiveActionTest extends
454		*/
455		public void testForkTimedGetNPE() {
456		RecursiveAction a = new CheckedRecursiveAction() {
457	<	public void realCompute() throws Exception {
457	>	protected void realCompute() throws Exception {
458		FibAction f = new FibAction(8);
459		assertSame(f, f.fork());
460		try {
#	Line 367 | Line 470 | public class RecursiveActionTest extends
470		*/
471		public void testForkQuietlyJoin() {
472		RecursiveAction a = new CheckedRecursiveAction() {
473	<	public void realCompute() {
473	>	protected void realCompute() {
474		FibAction f = new FibAction(8);
475		assertSame(f, f.fork());
476		f.quietlyJoin();
#	Line 377 | Line 480 | public class RecursiveActionTest extends
480		testInvokeOnPool(mainPool(), a);
481		}
482
380	–
483		/**
484		* helpQuiesce returns when tasks are complete.
485		* getQueuedTaskCount returns 0 when quiescent
486		*/
487		public void testForkHelpQuiesce() {
488		RecursiveAction a = new CheckedRecursiveAction() {
489	<	public void realCompute() {
489	>	protected void realCompute() {
490		FibAction f = new FibAction(8);
491		assertSame(f, f.fork());
492	<	f.helpQuiesce();
492	>	helpQuiesce();
493	>	while (!f.isDone()) // wait out race
494	>	;
495		assertEquals(21, f.result);
496		assertEquals(0, getQueuedTaskCount());
497		checkCompletedNormally(f);
#	Line 395 | Line 499 | public class RecursiveActionTest extends
499		testInvokeOnPool(mainPool(), a);
500		}
501
398	–
502		/**
503		* invoke task throws exception when task completes abnormally
504		*/
505		public void testAbnormalInvoke() {
506		RecursiveAction a = new CheckedRecursiveAction() {
507	<	public void realCompute() {
507	>	protected void realCompute() {
508		FailingFibAction f = new FailingFibAction(8);
509		try {
510		f.invoke();
#	Line 418 | Line 521 | public class RecursiveActionTest extends
521		*/
522		public void testAbnormalQuietlyInvoke() {
523		RecursiveAction a = new CheckedRecursiveAction() {
524	<	public void realCompute() {
524	>	protected void realCompute() {
525		FailingFibAction f = new FailingFibAction(8);
526		f.quietlyInvoke();
527		assertTrue(f.getException() instanceof FJException);
#	Line 432 | Line 535 | public class RecursiveActionTest extends
535		*/
536		public void testAbnormalForkJoin() {
537		RecursiveAction a = new CheckedRecursiveAction() {
538	<	public void realCompute() {
538	>	protected void realCompute() {
539		FailingFibAction f = new FailingFibAction(8);
540		assertSame(f, f.fork());
541		try {
#	Line 450 | Line 553 | public class RecursiveActionTest extends
553		*/
554		public void testAbnormalForkGet() {
555		RecursiveAction a = new CheckedRecursiveAction() {
556	<	public void realCompute() throws Exception {
556	>	protected void realCompute() throws Exception {
557		FailingFibAction f = new FailingFibAction(8);
558		assertSame(f, f.fork());
559		try {
#	Line 470 | Line 573 | public class RecursiveActionTest extends
573		*/
574		public void testAbnormalForkTimedGet() {
575		RecursiveAction a = new CheckedRecursiveAction() {
576	<	public void realCompute() throws Exception {
576	>	protected void realCompute() throws Exception {
577		FailingFibAction f = new FailingFibAction(8);
578		assertSame(f, f.fork());
579		try {
580	<	f.get(5L, TimeUnit.SECONDS);
580	>	f.get(5L, SECONDS);
581		shouldThrow();
582		} catch (ExecutionException success) {
583		Throwable cause = success.getCause();
#	Line 490 | Line 593 | public class RecursiveActionTest extends
593		*/
594		public void testAbnormalForkQuietlyJoin() {
595		RecursiveAction a = new CheckedRecursiveAction() {
596	<	public void realCompute() {
596	>	protected void realCompute() {
597		FailingFibAction f = new FailingFibAction(8);
598		assertSame(f, f.fork());
599		f.quietlyJoin();
#	Line 505 | Line 608 | public class RecursiveActionTest extends
608		*/
609		public void testCancelledInvoke() {
610		RecursiveAction a = new CheckedRecursiveAction() {
611	<	public void realCompute() {
611	>	protected void realCompute() {
612		FibAction f = new FibAction(8);
613		assertTrue(f.cancel(true));
614		try {
#	Line 523 | Line 626 | public class RecursiveActionTest extends
626		*/
627		public void testCancelledForkJoin() {
628		RecursiveAction a = new CheckedRecursiveAction() {
629	<	public void realCompute() {
629	>	protected void realCompute() {
630		FibAction f = new FibAction(8);
631		assertTrue(f.cancel(true));
632		assertSame(f, f.fork());
#	Line 542 | Line 645 | public class RecursiveActionTest extends
645		*/
646		public void testCancelledForkGet() {
647		RecursiveAction a = new CheckedRecursiveAction() {
648	<	public void realCompute() throws Exception {
648	>	protected void realCompute() throws Exception {
649		FibAction f = new FibAction(8);
650		assertTrue(f.cancel(true));
651		assertSame(f, f.fork());
#	Line 561 | Line 664 | public class RecursiveActionTest extends
664		*/
665		public void testCancelledForkTimedGet() {
666		RecursiveAction a = new CheckedRecursiveAction() {
667	<	public void realCompute() throws Exception {
667	>	protected void realCompute() throws Exception {
668		FibAction f = new FibAction(8);
669		assertTrue(f.cancel(true));
670		assertSame(f, f.fork());
#	Line 580 | Line 683 | public class RecursiveActionTest extends
683		*/
684		public void testCancelledForkQuietlyJoin() {
685		RecursiveAction a = new CheckedRecursiveAction() {
686	<	public void realCompute() {
686	>	protected void realCompute() {
687		FibAction f = new FibAction(8);
688		assertTrue(f.cancel(true));
689		assertSame(f, f.fork());
#	Line 596 | Line 699 | public class RecursiveActionTest extends
699		public void testGetPool() {
700		final ForkJoinPool mainPool = mainPool();
701		RecursiveAction a = new CheckedRecursiveAction() {
702	<	public void realCompute() {
702	>	protected void realCompute() {
703		assertSame(mainPool, getPool());
704		}};
705		testInvokeOnPool(mainPool, a);
#	Line 607 | Line 710 | public class RecursiveActionTest extends
710		*/
711		public void testGetPool2() {
712		RecursiveAction a = new CheckedRecursiveAction() {
713	<	public void realCompute() {
713	>	protected void realCompute() {
714		assertNull(getPool());
715		}};
716		assertNull(a.invoke());
#	Line 618 | Line 721 | public class RecursiveActionTest extends
721		*/
722		public void testInForkJoinPool() {
723		RecursiveAction a = new CheckedRecursiveAction() {
724	<	public void realCompute() {
724	>	protected void realCompute() {
725		assertTrue(inForkJoinPool());
726		}};
727		testInvokeOnPool(mainPool(), a);
#	Line 629 | Line 732 | public class RecursiveActionTest extends
732		*/
733		public void testInForkJoinPool2() {
734		RecursiveAction a = new CheckedRecursiveAction() {
735	<	public void realCompute() {
735	>	protected void realCompute() {
736		assertFalse(inForkJoinPool());
737		}};
738		assertNull(a.invoke());
#	Line 641 | Line 744 | public class RecursiveActionTest extends
744		public void testWorkerGetPool() {
745		final ForkJoinPool mainPool = mainPool();
746		RecursiveAction a = new CheckedRecursiveAction() {
747	<	public void realCompute() {
747	>	protected void realCompute() {
748		ForkJoinWorkerThread w =
749		(ForkJoinWorkerThread) Thread.currentThread();
750		assertSame(mainPool, w.getPool());
#	Line 655 | Line 758 | public class RecursiveActionTest extends
758		public void testWorkerGetPoolIndex() {
759		final ForkJoinPool mainPool = mainPool();
760		RecursiveAction a = new CheckedRecursiveAction() {
761	<	public void realCompute() {
761	>	protected void realCompute() {
762		ForkJoinWorkerThread w =
763	<	(ForkJoinWorkerThread)(Thread.currentThread());
763	>	(ForkJoinWorkerThread) Thread.currentThread();
764		assertTrue(w.getPoolIndex() >= 0);
765	<	assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
765	>	// pool size can shrink after assigning index, so cannot check
766	>	// assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
767		}};
768		testInvokeOnPool(mainPool, a);
769		}
770
667	–
771		/**
772		* setRawResult(null) succeeds
773		*/
774		public void testSetRawResult() {
775		RecursiveAction a = new CheckedRecursiveAction() {
776	<	public void realCompute() {
776	>	protected void realCompute() {
777		setRawResult(null);
778		assertNull(getRawResult());
779		}};
#	Line 678 | Line 781 | public class RecursiveActionTest extends
781		}
782
783		/**
784	<	* A reinitialized task may be re-invoked
784	>	* A reinitialized normally completed task may be re-invoked
785		*/
786		public void testReinitialize() {
787		RecursiveAction a = new CheckedRecursiveAction() {
788	<	public void realCompute() {
788	>	protected void realCompute() {
789		FibAction f = new FibAction(8);
790		checkNotDone(f);
791
#	Line 698 | Line 801 | public class RecursiveActionTest extends
801		}
802
803		/**
804	+	* A reinitialized abnormally completed task may be re-invoked
805	+	*/
806	+	public void testReinitializeAbnormal() {
807	+	RecursiveAction a = new CheckedRecursiveAction() {
808	+	protected void realCompute() {
809	+	FailingFibAction f = new FailingFibAction(8);
810	+	checkNotDone(f);
811	+
812	+	for (int i = 0; i < 3; i++) {
813	+	try {
814	+	f.invoke();
815	+	shouldThrow();
816	+	} catch (FJException success) {
817	+	checkCompletedAbnormally(f, success);
818	+	}
819	+	f.reinitialize();
820	+	checkNotDone(f);
821	+	}
822	+	}};
823	+	testInvokeOnPool(mainPool(), a);
824	+	}
825	+
826	+	/**
827		* invoke task throws exception after invoking completeExceptionally
828		*/
829		public void testCompleteExceptionally() {
830		RecursiveAction a = new CheckedRecursiveAction() {
831	<	public void realCompute() {
831	>	protected void realCompute() {
832		FibAction f = new FibAction(8);
833		f.completeExceptionally(new FJException());
834		try {
#	Line 720 | Line 846 | public class RecursiveActionTest extends
846		*/
847		public void testComplete() {
848		RecursiveAction a = new CheckedRecursiveAction() {
849	<	public void realCompute() {
849	>	protected void realCompute() {
850		FibAction f = new FibAction(8);
851		f.complete(null);
852		assertNull(f.invoke());
#	Line 735 | Line 861 | public class RecursiveActionTest extends
861		*/
862		public void testInvokeAll2() {
863		RecursiveAction a = new CheckedRecursiveAction() {
864	<	public void realCompute() {
864	>	protected void realCompute() {
865		FibAction f = new FibAction(8);
866		FibAction g = new FibAction(9);
867		invokeAll(f, g);
#	Line 752 | Line 878 | public class RecursiveActionTest extends
878		*/
879		public void testInvokeAll1() {
880		RecursiveAction a = new CheckedRecursiveAction() {
881	<	public void realCompute() {
881	>	protected void realCompute() {
882		FibAction f = new FibAction(8);
883		invokeAll(f);
884		checkCompletedNormally(f);
#	Line 766 | Line 892 | public class RecursiveActionTest extends
892		*/
893		public void testInvokeAll3() {
894		RecursiveAction a = new CheckedRecursiveAction() {
895	<	public void realCompute() {
895	>	protected void realCompute() {
896		FibAction f = new FibAction(8);
897		FibAction g = new FibAction(9);
898		FibAction h = new FibAction(7);
#	Line 789 | Line 915 | public class RecursiveActionTest extends
915		*/
916		public void testInvokeAllCollection() {
917		RecursiveAction a = new CheckedRecursiveAction() {
918	<	public void realCompute() {
918	>	protected void realCompute() {
919		FibAction f = new FibAction(8);
920		FibAction g = new FibAction(9);
921		FibAction h = new FibAction(7);
#	Line 811 | Line 937 | public class RecursiveActionTest extends
937		testInvokeOnPool(mainPool(), a);
938		}
939
814	–
940		/**
941		* invokeAll(tasks) with any null task throws NPE
942		*/
943		public void testInvokeAllNPE() {
944		RecursiveAction a = new CheckedRecursiveAction() {
945	<	public void realCompute() {
945	>	protected void realCompute() {
946		FibAction f = new FibAction(8);
947		FibAction g = new FibAction(9);
948		FibAction h = null;
#	Line 834 | Line 959 | public class RecursiveActionTest extends
959		*/
960		public void testAbnormalInvokeAll2() {
961		RecursiveAction a = new CheckedRecursiveAction() {
962	<	public void realCompute() {
962	>	protected void realCompute() {
963		FibAction f = new FibAction(8);
964		FailingFibAction g = new FailingFibAction(9);
965		try {
#	Line 852 | Line 977 | public class RecursiveActionTest extends
977		*/
978		public void testAbnormalInvokeAll1() {
979		RecursiveAction a = new CheckedRecursiveAction() {
980	<	public void realCompute() {
980	>	protected void realCompute() {
981		FailingFibAction g = new FailingFibAction(9);
982		try {
983		invokeAll(g);
#	Line 869 | Line 994 | public class RecursiveActionTest extends
994		*/
995		public void testAbnormalInvokeAll3() {
996		RecursiveAction a = new CheckedRecursiveAction() {
997	<	public void realCompute() {
997	>	protected void realCompute() {
998		FibAction f = new FibAction(8);
999		FailingFibAction g = new FailingFibAction(9);
1000		FibAction h = new FibAction(7);
#	Line 888 | Line 1013 | public class RecursiveActionTest extends
1013		*/
1014		public void testAbnormalInvokeAllCollection() {
1015		RecursiveAction a = new CheckedRecursiveAction() {
1016	<	public void realCompute() {
1016	>	protected void realCompute() {
1017		FailingFibAction f = new FailingFibAction(8);
1018		FibAction g = new FibAction(9);
1019		FibAction h = new FibAction(7);
#	Line 912 | Line 1037 | public class RecursiveActionTest extends
1037		*/
1038		public void testTryUnfork() {
1039		RecursiveAction a = new CheckedRecursiveAction() {
1040	<	public void realCompute() {
1040	>	protected void realCompute() {
1041		FibAction g = new FibAction(9);
1042		assertSame(g, g.fork());
1043		FibAction f = new FibAction(8);
#	Line 931 | Line 1056 | public class RecursiveActionTest extends
1056		*/
1057		public void testGetSurplusQueuedTaskCount() {
1058		RecursiveAction a = new CheckedRecursiveAction() {
1059	<	public void realCompute() {
1059	>	protected void realCompute() {
1060		FibAction h = new FibAction(7);
1061		assertSame(h, h.fork());
1062		FibAction g = new FibAction(9);
#	Line 953 | Line 1078 | public class RecursiveActionTest extends
1078		*/
1079		public void testPeekNextLocalTask() {
1080		RecursiveAction a = new CheckedRecursiveAction() {
1081	<	public void realCompute() {
1081	>	protected void realCompute() {
1082		FibAction g = new FibAction(9);
1083		assertSame(g, g.fork());
1084		FibAction f = new FibAction(8);
#	Line 974 | Line 1099 | public class RecursiveActionTest extends
1099		*/
1100		public void testPollNextLocalTask() {
1101		RecursiveAction a = new CheckedRecursiveAction() {
1102	<	public void realCompute() {
1102	>	protected void realCompute() {
1103		FibAction g = new FibAction(9);
1104		assertSame(g, g.fork());
1105		FibAction f = new FibAction(8);
#	Line 992 | Line 1117 | public class RecursiveActionTest extends
1117		*/
1118		public void testPollTask() {
1119		RecursiveAction a = new CheckedRecursiveAction() {
1120	<	public void realCompute() {
1120	>	protected void realCompute() {
1121		FibAction g = new FibAction(9);
1122		assertSame(g, g.fork());
1123		FibAction f = new FibAction(8);
#	Line 1010 | Line 1135 | public class RecursiveActionTest extends
1135		*/
1136		public void testPeekNextLocalTaskAsync() {
1137		RecursiveAction a = new CheckedRecursiveAction() {
1138	<	public void realCompute() {
1138	>	protected void realCompute() {
1139		FibAction g = new FibAction(9);
1140		assertSame(g, g.fork());
1141		FibAction f = new FibAction(8);
#	Line 1030 | Line 1155 | public class RecursiveActionTest extends
1155		*/
1156		public void testPollNextLocalTaskAsync() {
1157		RecursiveAction a = new CheckedRecursiveAction() {
1158	<	public void realCompute() {
1158	>	protected void realCompute() {
1159		FibAction g = new FibAction(9);
1160		assertSame(g, g.fork());
1161		FibAction f = new FibAction(8);
#	Line 1049 | Line 1174 | public class RecursiveActionTest extends
1174		*/
1175		public void testPollTaskAsync() {
1176		RecursiveAction a = new CheckedRecursiveAction() {
1177	<	public void realCompute() {
1177	>	protected void realCompute() {
1178		FibAction g = new FibAction(9);
1179		assertSame(g, g.fork());
1180		FibAction f = new FibAction(8);
#	Line 1062 | Line 1187 | public class RecursiveActionTest extends
1187		testInvokeOnPool(asyncSingletonPool(), a);
1188		}
1189
1190	+	/** Demo from RecursiveAction javadoc */
1191	+	static class SortTask extends RecursiveAction {
1192	+	final long[] array; final int lo, hi;
1193	+	SortTask(long[] array, int lo, int hi) {
1194	+	this.array = array; this.lo = lo; this.hi = hi;
1195	+	}
1196	+	SortTask(long[] array) { this(array, 0, array.length); }
1197	+	protected void compute() {
1198	+	if (hi - lo < THRESHOLD)
1199	+	sortSequentially(lo, hi);
1200	+	else {
1201	+	int mid = (lo + hi) >>> 1;
1202	+	invokeAll(new SortTask(array, lo, mid),
1203	+	new SortTask(array, mid, hi));
1204	+	merge(lo, mid, hi);
1205	+	}
1206	+	}
1207	+	// implementation details follow:
1208	+	static final int THRESHOLD = 100;
1209	+	void sortSequentially(int lo, int hi) {
1210	+	Arrays.sort(array, lo, hi);
1211	+	}
1212	+	void merge(int lo, int mid, int hi) {
1213	+	long[] buf = Arrays.copyOfRange(array, lo, mid);
1214	+	for (int i = 0, j = lo, k = mid; i < buf.length; j++)
1215	+	array[j] = (k == hi || buf[i] < array[k]) ?
1216	+	buf[i++] : array[k++];
1217	+	}
1218	+	}
1219	+
1220	+	/**
1221	+	* SortTask demo works as advertised
1222	+	*/
1223	+	public void testSortTaskDemo() {
1224	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
1225	+	long[] array = new long[1007];
1226	+	for (int i = 0; i < array.length; i++)
1227	+	array[i] = rnd.nextLong();
1228	+	long[] arrayClone = array.clone();
1229	+	testInvokeOnPool(mainPool(), new SortTask(array));
1230	+	Arrays.sort(arrayClone);
1231	+	assertTrue(Arrays.equals(array, arrayClone));
1232	+	}
1233		}

Diff Legend

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