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.21 by jsr166, Sun Nov 21 19:06:53 2010 UTC vs.
Revision 1.47 by jsr166, Tue Aug 16 23:02:57 2016 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 90 | Line 94 | public class RecursiveActionTest extends
94		assertNull(a.getException());
95		assertNull(a.getRawResult());
96		assertNull(a.join());
97	+	assertFalse(a.cancel(false));
98	+	assertFalse(a.cancel(true));
99		try {
100		assertNull(a.get());
101		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 130 | 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));
143
144		try {
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
#	Line 164 | Line 173 | public class RecursiveActionTest extends
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 202 | 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 218 | 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 232 | 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 243 | Line 252 | public class RecursiveActionTest extends
252		}
253
254		/**
255	+	* join/quietlyJoin of a forked task succeeds in the presence of interrupts
256	+	*/
257	+	public void testJoinIgnoresInterrupts() {
258	+	RecursiveAction a = new CheckedRecursiveAction() {
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	+	currentThread.interrupt();
266	+	assertTrue(currentThread.isInterrupted());
267	+	assertNull(f.join());
268	+	Thread.interrupted();
269	+	assertEquals(21, f.result);
270	+	checkCompletedNormally(f);
271	+
272	+	f = new FibAction(8);
273	+	f.cancel(true);
274	+	assertSame(f, f.fork());
275	+	currentThread.interrupt();
276	+	assertTrue(currentThread.isInterrupted());
277	+	try {
278	+	f.join();
279	+	shouldThrow();
280	+	} catch (CancellationException success) {
281	+	Thread.interrupted();
282	+	checkCancelled(f);
283	+	}
284	+
285	+	f = new FibAction(8);
286	+	f.completeExceptionally(new FJException());
287	+	assertSame(f, f.fork());
288	+	currentThread.interrupt();
289	+	assertTrue(currentThread.isInterrupted());
290	+	try {
291	+	f.join();
292	+	shouldThrow();
293	+	} catch (FJException success) {
294	+	Thread.interrupted();
295	+	checkCompletedAbnormally(f, success);
296	+	}
297	+
298	+	// test quietlyJoin()
299	+	f = new FibAction(8);
300	+	assertSame(f, f.fork());
301	+	currentThread.interrupt();
302	+	assertTrue(currentThread.isInterrupted());
303	+	f.quietlyJoin();
304	+	Thread.interrupted();
305	+	assertEquals(21, f.result);
306	+	checkCompletedNormally(f);
307	+
308	+	f = new FibAction(8);
309	+	f.cancel(true);
310	+	assertSame(f, f.fork());
311	+	currentThread.interrupt();
312	+	assertTrue(currentThread.isInterrupted());
313	+	f.quietlyJoin();
314	+	Thread.interrupted();
315	+	checkCancelled(f);
316	+
317	+	f = new FibAction(8);
318	+	f.completeExceptionally(new FJException());
319	+	assertSame(f, f.fork());
320	+	currentThread.interrupt();
321	+	assertTrue(currentThread.isInterrupted());
322	+	f.quietlyJoin();
323	+	Thread.interrupted();
324	+	checkCompletedAbnormally(f, f.getException());
325	+	}};
326	+	testInvokeOnPool(mainPool(), a);
327	+	a.reinitialize();
328	+	testInvokeOnPool(singletonPool(), a);
329	+	}
330	+
331	+	/**
332	+	* join/quietlyJoin of a forked task when not in ForkJoinPool
333	+	* succeeds in the presence of interrupts
334	+	*/
335	+	public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
336	+	final SynchronousQueue<FibAction[]> sq =
337	+	new SynchronousQueue<FibAction[]>();
338	+	RecursiveAction a = new CheckedRecursiveAction() {
339	+	protected void realCompute() throws InterruptedException {
340	+	FibAction[] fibActions = new FibAction[6];
341	+	for (int i = 0; i < fibActions.length; i++)
342	+	fibActions[i] = new FibAction(8);
343	+
344	+	fibActions[1].cancel(false);
345	+	fibActions[2].completeExceptionally(new FJException());
346	+	fibActions[4].cancel(true);
347	+	fibActions[5].completeExceptionally(new FJException());
348	+
349	+	for (int i = 0; i < fibActions.length; i++)
350	+	fibActions[i].fork();
351	+
352	+	sq.put(fibActions);
353	+
354	+	helpQuiesce();
355	+	}};
356	+
357	+	Runnable r = new CheckedRunnable() {
358	+	public void realRun() throws InterruptedException {
359	+	FibAction[] fibActions = sq.take();
360	+	FibAction f;
361	+	final Thread currentThread = Thread.currentThread();
362	+
363	+	// test join() ------------
364	+
365	+	f = fibActions[0];
366	+	assertFalse(ForkJoinTask.inForkJoinPool());
367	+	currentThread.interrupt();
368	+	assertTrue(currentThread.isInterrupted());
369	+	assertNull(f.join());
370	+	assertTrue(Thread.interrupted());
371	+	assertEquals(21, f.result);
372	+	checkCompletedNormally(f);
373	+
374	+	f = fibActions[1];
375	+	currentThread.interrupt();
376	+	assertTrue(currentThread.isInterrupted());
377	+	try {
378	+	f.join();
379	+	shouldThrow();
380	+	} catch (CancellationException success) {
381	+	assertTrue(Thread.interrupted());
382	+	checkCancelled(f);
383	+	}
384	+
385	+	f = fibActions[2];
386	+	currentThread.interrupt();
387	+	assertTrue(currentThread.isInterrupted());
388	+	try {
389	+	f.join();
390	+	shouldThrow();
391	+	} catch (FJException success) {
392	+	assertTrue(Thread.interrupted());
393	+	checkCompletedAbnormally(f, success);
394	+	}
395	+
396	+	// test quietlyJoin() ---------
397	+
398	+	f = fibActions[3];
399	+	currentThread.interrupt();
400	+	assertTrue(currentThread.isInterrupted());
401	+	f.quietlyJoin();
402	+	assertTrue(Thread.interrupted());
403	+	assertEquals(21, f.result);
404	+	checkCompletedNormally(f);
405	+
406	+	f = fibActions[4];
407	+	currentThread.interrupt();
408	+	assertTrue(currentThread.isInterrupted());
409	+	f.quietlyJoin();
410	+	assertTrue(Thread.interrupted());
411	+	checkCancelled(f);
412	+
413	+	f = fibActions[5];
414	+	currentThread.interrupt();
415	+	assertTrue(currentThread.isInterrupted());
416	+	f.quietlyJoin();
417	+	assertTrue(Thread.interrupted());
418	+	assertTrue(f.getException() instanceof FJException);
419	+	checkCompletedAbnormally(f, f.getException());
420	+	}};
421	+
422	+	Thread t;
423	+
424	+	t = newStartedThread(r);
425	+	testInvokeOnPool(mainPool(), a);
426	+	awaitTermination(t);
427	+
428	+	a.reinitialize();
429	+	t = newStartedThread(r);
430	+	testInvokeOnPool(singletonPool(), a);
431	+	awaitTermination(t);
432	+	}
433	+
434	+	/**
435		* get of a forked task returns when task completes
436		*/
437		public void testForkGet() {
438		RecursiveAction a = new CheckedRecursiveAction() {
439	<	public void realCompute() throws Exception {
439	>	protected void realCompute() throws Exception {
440		FibAction f = new FibAction(8);
441		assertSame(f, f.fork());
442		assertNull(f.get());
#	Line 262 | Line 451 | public class RecursiveActionTest extends
451		*/
452		public void testForkTimedGet() {
453		RecursiveAction a = new CheckedRecursiveAction() {
454	<	public void realCompute() throws Exception {
454	>	protected void realCompute() throws Exception {
455		FibAction f = new FibAction(8);
456		assertSame(f, f.fork());
457		assertNull(f.get(5L, SECONDS));
#	Line 277 | Line 466 | public class RecursiveActionTest extends
466		*/
467		public void testForkTimedGetNPE() {
468		RecursiveAction a = new CheckedRecursiveAction() {
469	<	public void realCompute() throws Exception {
469	>	protected void realCompute() throws Exception {
470		FibAction f = new FibAction(8);
471		assertSame(f, f.fork());
472		try {
#	Line 293 | Line 482 | public class RecursiveActionTest extends
482		*/
483		public void testForkQuietlyJoin() {
484		RecursiveAction a = new CheckedRecursiveAction() {
485	<	public void realCompute() {
485	>	protected void realCompute() {
486		FibAction f = new FibAction(8);
487		assertSame(f, f.fork());
488		f.quietlyJoin();
#	Line 303 | Line 492 | public class RecursiveActionTest extends
492		testInvokeOnPool(mainPool(), a);
493		}
494
306	–
495		/**
496		* helpQuiesce returns when tasks are complete.
497		* getQueuedTaskCount returns 0 when quiescent
498		*/
499		public void testForkHelpQuiesce() {
500		RecursiveAction a = new CheckedRecursiveAction() {
501	<	public void realCompute() {
501	>	protected void realCompute() {
502		FibAction f = new FibAction(8);
503		assertSame(f, f.fork());
504	<	f.helpQuiesce();
504	>	helpQuiesce();
505	>	while (!f.isDone()) // wait out race
506	>	;
507		assertEquals(21, f.result);
508		assertEquals(0, getQueuedTaskCount());
509		checkCompletedNormally(f);
#	Line 321 | Line 511 | public class RecursiveActionTest extends
511		testInvokeOnPool(mainPool(), a);
512		}
513
324	–
514		/**
515		* invoke task throws exception when task completes abnormally
516		*/
517		public void testAbnormalInvoke() {
518		RecursiveAction a = new CheckedRecursiveAction() {
519	<	public void realCompute() {
519	>	protected void realCompute() {
520		FailingFibAction f = new FailingFibAction(8);
521		try {
522		f.invoke();
#	Line 344 | Line 533 | public class RecursiveActionTest extends
533		*/
534		public void testAbnormalQuietlyInvoke() {
535		RecursiveAction a = new CheckedRecursiveAction() {
536	<	public void realCompute() {
536	>	protected void realCompute() {
537		FailingFibAction f = new FailingFibAction(8);
538		f.quietlyInvoke();
539		assertTrue(f.getException() instanceof FJException);
#	Line 358 | Line 547 | public class RecursiveActionTest extends
547		*/
548		public void testAbnormalForkJoin() {
549		RecursiveAction a = new CheckedRecursiveAction() {
550	<	public void realCompute() {
550	>	protected void realCompute() {
551		FailingFibAction f = new FailingFibAction(8);
552		assertSame(f, f.fork());
553		try {
#	Line 376 | Line 565 | public class RecursiveActionTest extends
565		*/
566		public void testAbnormalForkGet() {
567		RecursiveAction a = new CheckedRecursiveAction() {
568	<	public void realCompute() throws Exception {
568	>	protected void realCompute() throws Exception {
569		FailingFibAction f = new FailingFibAction(8);
570		assertSame(f, f.fork());
571		try {
#	Line 396 | Line 585 | public class RecursiveActionTest extends
585		*/
586		public void testAbnormalForkTimedGet() {
587		RecursiveAction a = new CheckedRecursiveAction() {
588	<	public void realCompute() throws Exception {
588	>	protected void realCompute() throws Exception {
589		FailingFibAction f = new FailingFibAction(8);
590		assertSame(f, f.fork());
591		try {
592	<	f.get(5L, TimeUnit.SECONDS);
592	>	f.get(5L, SECONDS);
593		shouldThrow();
594		} catch (ExecutionException success) {
595		Throwable cause = success.getCause();
#	Line 416 | Line 605 | public class RecursiveActionTest extends
605		*/
606		public void testAbnormalForkQuietlyJoin() {
607		RecursiveAction a = new CheckedRecursiveAction() {
608	<	public void realCompute() {
608	>	protected void realCompute() {
609		FailingFibAction f = new FailingFibAction(8);
610		assertSame(f, f.fork());
611		f.quietlyJoin();
#	Line 431 | Line 620 | public class RecursiveActionTest extends
620		*/
621		public void testCancelledInvoke() {
622		RecursiveAction a = new CheckedRecursiveAction() {
623	<	public void realCompute() {
623	>	protected void realCompute() {
624		FibAction f = new FibAction(8);
625		assertTrue(f.cancel(true));
626		try {
#	Line 449 | Line 638 | public class RecursiveActionTest extends
638		*/
639		public void testCancelledForkJoin() {
640		RecursiveAction a = new CheckedRecursiveAction() {
641	<	public void realCompute() {
641	>	protected void realCompute() {
642		FibAction f = new FibAction(8);
643		assertTrue(f.cancel(true));
644		assertSame(f, f.fork());
#	Line 468 | Line 657 | public class RecursiveActionTest extends
657		*/
658		public void testCancelledForkGet() {
659		RecursiveAction a = new CheckedRecursiveAction() {
660	<	public void realCompute() throws Exception {
660	>	protected void realCompute() throws Exception {
661		FibAction f = new FibAction(8);
662		assertTrue(f.cancel(true));
663		assertSame(f, f.fork());
#	Line 487 | Line 676 | public class RecursiveActionTest extends
676		*/
677		public void testCancelledForkTimedGet() {
678		RecursiveAction a = new CheckedRecursiveAction() {
679	<	public void realCompute() throws Exception {
679	>	protected void realCompute() throws Exception {
680		FibAction f = new FibAction(8);
681		assertTrue(f.cancel(true));
682		assertSame(f, f.fork());
#	Line 506 | Line 695 | public class RecursiveActionTest extends
695		*/
696		public void testCancelledForkQuietlyJoin() {
697		RecursiveAction a = new CheckedRecursiveAction() {
698	<	public void realCompute() {
698	>	protected void realCompute() {
699		FibAction f = new FibAction(8);
700		assertTrue(f.cancel(true));
701		assertSame(f, f.fork());
#	Line 522 | Line 711 | public class RecursiveActionTest extends
711		public void testGetPool() {
712		final ForkJoinPool mainPool = mainPool();
713		RecursiveAction a = new CheckedRecursiveAction() {
714	<	public void realCompute() {
714	>	protected void realCompute() {
715		assertSame(mainPool, getPool());
716		}};
717		testInvokeOnPool(mainPool, a);
#	Line 533 | Line 722 | public class RecursiveActionTest extends
722		*/
723		public void testGetPool2() {
724		RecursiveAction a = new CheckedRecursiveAction() {
725	<	public void realCompute() {
725	>	protected void realCompute() {
726		assertNull(getPool());
727		}};
728		assertNull(a.invoke());
#	Line 544 | Line 733 | public class RecursiveActionTest extends
733		*/
734		public void testInForkJoinPool() {
735		RecursiveAction a = new CheckedRecursiveAction() {
736	<	public void realCompute() {
736	>	protected void realCompute() {
737		assertTrue(inForkJoinPool());
738		}};
739		testInvokeOnPool(mainPool(), a);
#	Line 555 | Line 744 | public class RecursiveActionTest extends
744		*/
745		public void testInForkJoinPool2() {
746		RecursiveAction a = new CheckedRecursiveAction() {
747	<	public void realCompute() {
747	>	protected void realCompute() {
748		assertFalse(inForkJoinPool());
749		}};
750		assertNull(a.invoke());
#	Line 567 | Line 756 | public class RecursiveActionTest extends
756		public void testWorkerGetPool() {
757		final ForkJoinPool mainPool = mainPool();
758		RecursiveAction a = new CheckedRecursiveAction() {
759	<	public void realCompute() {
759	>	protected void realCompute() {
760		ForkJoinWorkerThread w =
761		(ForkJoinWorkerThread) Thread.currentThread();
762		assertSame(mainPool, w.getPool());
#	Line 581 | Line 770 | public class RecursiveActionTest extends
770		public void testWorkerGetPoolIndex() {
771		final ForkJoinPool mainPool = mainPool();
772		RecursiveAction a = new CheckedRecursiveAction() {
773	<	public void realCompute() {
773	>	protected void realCompute() {
774		ForkJoinWorkerThread w =
775	<	(ForkJoinWorkerThread)(Thread.currentThread());
775	>	(ForkJoinWorkerThread) Thread.currentThread();
776		assertTrue(w.getPoolIndex() >= 0);
777	<	assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
777	>	// pool size can shrink after assigning index, so cannot check
778	>	// assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
779		}};
780		testInvokeOnPool(mainPool, a);
781		}
782
593	–
783		/**
784		* setRawResult(null) succeeds
785		*/
786		public void testSetRawResult() {
787		RecursiveAction a = new CheckedRecursiveAction() {
788	<	public void realCompute() {
788	>	protected void realCompute() {
789		setRawResult(null);
790	+	assertNull(getRawResult());
791		}};
792		assertNull(a.invoke());
793		}
794
795		/**
796	<	* A reinitialized task may be re-invoked
796	>	* A reinitialized normally completed task may be re-invoked
797		*/
798		public void testReinitialize() {
799		RecursiveAction a = new CheckedRecursiveAction() {
800	<	public void realCompute() {
800	>	protected void realCompute() {
801		FibAction f = new FibAction(8);
802		checkNotDone(f);
803
#	Line 623 | Line 813 | public class RecursiveActionTest extends
813		}
814
815		/**
816	+	* A reinitialized abnormally completed task may be re-invoked
817	+	*/
818	+	public void testReinitializeAbnormal() {
819	+	RecursiveAction a = new CheckedRecursiveAction() {
820	+	protected void realCompute() {
821	+	FailingFibAction f = new FailingFibAction(8);
822	+	checkNotDone(f);
823	+
824	+	for (int i = 0; i < 3; i++) {
825	+	try {
826	+	f.invoke();
827	+	shouldThrow();
828	+	} catch (FJException success) {
829	+	checkCompletedAbnormally(f, success);
830	+	}
831	+	f.reinitialize();
832	+	checkNotDone(f);
833	+	}
834	+	}};
835	+	testInvokeOnPool(mainPool(), a);
836	+	}
837	+
838	+	/**
839		* invoke task throws exception after invoking completeExceptionally
840		*/
841		public void testCompleteExceptionally() {
842		RecursiveAction a = new CheckedRecursiveAction() {
843	<	public void realCompute() {
843	>	protected void realCompute() {
844		FibAction f = new FibAction(8);
845		f.completeExceptionally(new FJException());
846		try {
#	Line 645 | Line 858 | public class RecursiveActionTest extends
858		*/
859		public void testComplete() {
860		RecursiveAction a = new CheckedRecursiveAction() {
861	<	public void realCompute() {
861	>	protected void realCompute() {
862		FibAction f = new FibAction(8);
863		f.complete(null);
864		assertNull(f.invoke());
#	Line 660 | Line 873 | public class RecursiveActionTest extends
873		*/
874		public void testInvokeAll2() {
875		RecursiveAction a = new CheckedRecursiveAction() {
876	<	public void realCompute() {
876	>	protected void realCompute() {
877		FibAction f = new FibAction(8);
878		FibAction g = new FibAction(9);
879		invokeAll(f, g);
#	Line 677 | Line 890 | public class RecursiveActionTest extends
890		*/
891		public void testInvokeAll1() {
892		RecursiveAction a = new CheckedRecursiveAction() {
893	<	public void realCompute() {
893	>	protected void realCompute() {
894		FibAction f = new FibAction(8);
895		invokeAll(f);
896		checkCompletedNormally(f);
#	Line 691 | Line 904 | public class RecursiveActionTest extends
904		*/
905		public void testInvokeAll3() {
906		RecursiveAction a = new CheckedRecursiveAction() {
907	<	public void realCompute() {
907	>	protected void realCompute() {
908		FibAction f = new FibAction(8);
909		FibAction g = new FibAction(9);
910		FibAction h = new FibAction(7);
#	Line 714 | Line 927 | public class RecursiveActionTest extends
927		*/
928		public void testInvokeAllCollection() {
929		RecursiveAction a = new CheckedRecursiveAction() {
930	<	public void realCompute() {
930	>	protected void realCompute() {
931		FibAction f = new FibAction(8);
932		FibAction g = new FibAction(9);
933		FibAction h = new FibAction(7);
#	Line 736 | Line 949 | public class RecursiveActionTest extends
949		testInvokeOnPool(mainPool(), a);
950		}
951
739	–
952		/**
953		* invokeAll(tasks) with any null task throws NPE
954		*/
955		public void testInvokeAllNPE() {
956		RecursiveAction a = new CheckedRecursiveAction() {
957	<	public void realCompute() {
957	>	protected void realCompute() {
958		FibAction f = new FibAction(8);
959		FibAction g = new FibAction(9);
960		FibAction h = null;
#	Line 759 | Line 971 | public class RecursiveActionTest extends
971		*/
972		public void testAbnormalInvokeAll2() {
973		RecursiveAction a = new CheckedRecursiveAction() {
974	<	public void realCompute() {
974	>	protected void realCompute() {
975		FibAction f = new FibAction(8);
976		FailingFibAction g = new FailingFibAction(9);
977		try {
#	Line 777 | Line 989 | public class RecursiveActionTest extends
989		*/
990		public void testAbnormalInvokeAll1() {
991		RecursiveAction a = new CheckedRecursiveAction() {
992	<	public void realCompute() {
992	>	protected void realCompute() {
993		FailingFibAction g = new FailingFibAction(9);
994		try {
995		invokeAll(g);
#	Line 794 | Line 1006 | public class RecursiveActionTest extends
1006		*/
1007		public void testAbnormalInvokeAll3() {
1008		RecursiveAction a = new CheckedRecursiveAction() {
1009	<	public void realCompute() {
1009	>	protected void realCompute() {
1010		FibAction f = new FibAction(8);
1011		FailingFibAction g = new FailingFibAction(9);
1012		FibAction h = new FibAction(7);
#	Line 813 | Line 1025 | public class RecursiveActionTest extends
1025		*/
1026		public void testAbnormalInvokeAllCollection() {
1027		RecursiveAction a = new CheckedRecursiveAction() {
1028	<	public void realCompute() {
1028	>	protected void realCompute() {
1029		FailingFibAction f = new FailingFibAction(8);
1030		FibAction g = new FibAction(9);
1031		FibAction h = new FibAction(7);
#	Line 837 | Line 1049 | public class RecursiveActionTest extends
1049		*/
1050		public void testTryUnfork() {
1051		RecursiveAction a = new CheckedRecursiveAction() {
1052	<	public void realCompute() {
1052	>	protected void realCompute() {
1053		FibAction g = new FibAction(9);
1054		assertSame(g, g.fork());
1055		FibAction f = new FibAction(8);
#	Line 856 | Line 1068 | public class RecursiveActionTest extends
1068		*/
1069		public void testGetSurplusQueuedTaskCount() {
1070		RecursiveAction a = new CheckedRecursiveAction() {
1071	<	public void realCompute() {
1071	>	protected void realCompute() {
1072		FibAction h = new FibAction(7);
1073		assertSame(h, h.fork());
1074		FibAction g = new FibAction(9);
#	Line 878 | Line 1090 | public class RecursiveActionTest extends
1090		*/
1091		public void testPeekNextLocalTask() {
1092		RecursiveAction a = new CheckedRecursiveAction() {
1093	<	public void realCompute() {
1093	>	protected void realCompute() {
1094		FibAction g = new FibAction(9);
1095		assertSame(g, g.fork());
1096		FibAction f = new FibAction(8);
#	Line 899 | Line 1111 | public class RecursiveActionTest extends
1111		*/
1112		public void testPollNextLocalTask() {
1113		RecursiveAction a = new CheckedRecursiveAction() {
1114	<	public void realCompute() {
1114	>	protected void realCompute() {
1115		FibAction g = new FibAction(9);
1116		assertSame(g, g.fork());
1117		FibAction f = new FibAction(8);
#	Line 917 | Line 1129 | public class RecursiveActionTest extends
1129		*/
1130		public void testPollTask() {
1131		RecursiveAction a = new CheckedRecursiveAction() {
1132	<	public void realCompute() {
1132	>	protected void realCompute() {
1133		FibAction g = new FibAction(9);
1134		assertSame(g, g.fork());
1135		FibAction f = new FibAction(8);
#	Line 935 | Line 1147 | public class RecursiveActionTest extends
1147		*/
1148		public void testPeekNextLocalTaskAsync() {
1149		RecursiveAction a = new CheckedRecursiveAction() {
1150	<	public void realCompute() {
1150	>	protected void realCompute() {
1151		FibAction g = new FibAction(9);
1152		assertSame(g, g.fork());
1153		FibAction f = new FibAction(8);
#	Line 955 | Line 1167 | public class RecursiveActionTest extends
1167		*/
1168		public void testPollNextLocalTaskAsync() {
1169		RecursiveAction a = new CheckedRecursiveAction() {
1170	<	public void realCompute() {
1170	>	protected void realCompute() {
1171		FibAction g = new FibAction(9);
1172		assertSame(g, g.fork());
1173		FibAction f = new FibAction(8);
#	Line 974 | Line 1186 | public class RecursiveActionTest extends
1186		*/
1187		public void testPollTaskAsync() {
1188		RecursiveAction a = new CheckedRecursiveAction() {
1189	<	public void realCompute() {
1189	>	protected void realCompute() {
1190		FibAction g = new FibAction(9);
1191		assertSame(g, g.fork());
1192		FibAction f = new FibAction(8);
#	Line 987 | Line 1199 | public class RecursiveActionTest extends
1199		testInvokeOnPool(asyncSingletonPool(), a);
1200		}
1201
1202	+	/** Demo from RecursiveAction javadoc */
1203	+	static class SortTask extends RecursiveAction {
1204	+	final long[] array; final int lo, hi;
1205	+	SortTask(long[] array, int lo, int hi) {
1206	+	this.array = array; this.lo = lo; this.hi = hi;
1207	+	}
1208	+	SortTask(long[] array) { this(array, 0, array.length); }
1209	+	protected void compute() {
1210	+	if (hi - lo < THRESHOLD)
1211	+	sortSequentially(lo, hi);
1212	+	else {
1213	+	int mid = (lo + hi) >>> 1;
1214	+	invokeAll(new SortTask(array, lo, mid),
1215	+	new SortTask(array, mid, hi));
1216	+	merge(lo, mid, hi);
1217	+	}
1218	+	}
1219	+	// implementation details follow:
1220	+	static final int THRESHOLD = 100;
1221	+	void sortSequentially(int lo, int hi) {
1222	+	Arrays.sort(array, lo, hi);
1223	+	}
1224	+	void merge(int lo, int mid, int hi) {
1225	+	long[] buf = Arrays.copyOfRange(array, lo, mid);
1226	+	for (int i = 0, j = lo, k = mid; i < buf.length; j++)
1227	+	array[j] = (k == hi || buf[i] < array[k]) ?
1228	+	buf[i++] : array[k++];
1229	+	}
1230	+	}
1231	+
1232	+	/**
1233	+	* SortTask demo works as advertised
1234	+	*/
1235	+	public void testSortTaskDemo() {
1236	+	ThreadLocalRandom rnd = ThreadLocalRandom.current();
1237	+	long[] array = new long[1007];
1238	+	for (int i = 0; i < array.length; i++)
1239	+	array[i] = rnd.nextLong();
1240	+	long[] arrayClone = array.clone();
1241	+	testInvokeOnPool(mainPool(), new SortTask(array));
1242	+	Arrays.sort(arrayClone);
1243	+	assertTrue(Arrays.equals(array, arrayClone));
1244	+	}
1245		}

Diff Legend

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