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/publicdomain/zero/1.0/
5  */
6 
7 package jsr166;
8 
9 import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 import static java.util.concurrent.TimeUnit.SECONDS;
11 
12 import java.util.HashSet;
13 import java.util.concurrent.CancellationException;
14 import java.util.concurrent.CountedCompleter;
15 import java.util.concurrent.ExecutionException;
16 import java.util.concurrent.ForkJoinPool;
17 import java.util.concurrent.ForkJoinTask;
18 import java.util.concurrent.TimeoutException;
19 import java.util.concurrent.atomic.AtomicInteger;
20 import java.util.concurrent.atomic.AtomicReference;
21 
22 import junit.framework.Test;
23 import junit.framework.TestSuite;
24 
25 public class CountedCompleterTest extends JSR166TestCase {
26 
27     // android-note: Removed because the CTS runner does a bad job of
28     // retrying tests that have suite() declarations.
29     //
30     // public static void main(String[] args) {
31     //     main(suite(), args);
32     // }
33     // public static Test suite() {
34     //     return new TestSuite(CountedCompleterTest.class);
35     // }
36 
37     // Runs with "mainPool" use > 1 thread. singletonPool tests use 1
38     static final int mainPoolSize =
39         Math.max(2, Runtime.getRuntime().availableProcessors());
40 
mainPool()41     private static ForkJoinPool mainPool() {
42         return new ForkJoinPool(mainPoolSize);
43     }
44 
singletonPool()45     private static ForkJoinPool singletonPool() {
46         return new ForkJoinPool(1);
47     }
48 
asyncSingletonPool()49     private static ForkJoinPool asyncSingletonPool() {
50         return new ForkJoinPool(1,
51                                 ForkJoinPool.defaultForkJoinWorkerThreadFactory,
52                                 null, true);
53     }
54 
testInvokeOnPool(ForkJoinPool pool, ForkJoinTask a)55     private void testInvokeOnPool(ForkJoinPool pool, ForkJoinTask a) {
56         try (PoolCleaner cleaner = cleaner(pool)) {
57             assertFalse(a.isDone());
58             assertFalse(a.isCompletedNormally());
59             assertFalse(a.isCompletedAbnormally());
60             assertFalse(a.isCancelled());
61             assertNull(a.getException());
62             assertNull(a.getRawResult());
63 
64             assertNull(pool.invoke(a));
65 
66             assertTrue(a.isDone());
67             assertTrue(a.isCompletedNormally());
68             assertFalse(a.isCompletedAbnormally());
69             assertFalse(a.isCancelled());
70             assertNull(a.getException());
71             assertNull(a.getRawResult());
72         }
73     }
74 
checkNotDone(CountedCompleter a)75     void checkNotDone(CountedCompleter a) {
76         assertFalse(a.isDone());
77         assertFalse(a.isCompletedNormally());
78         assertFalse(a.isCompletedAbnormally());
79         assertFalse(a.isCancelled());
80         assertNull(a.getException());
81         assertNull(a.getRawResult());
82 
83         try {
84             a.get(0L, SECONDS);
85             shouldThrow();
86         } catch (TimeoutException success) {
87         } catch (Throwable fail) { threadUnexpectedException(fail); }
88     }
89 
checkCompletedNormally(CountedCompleter<?> a)90     void checkCompletedNormally(CountedCompleter<?> a) {
91         assertTrue(a.isDone());
92         assertFalse(a.isCancelled());
93         assertTrue(a.isCompletedNormally());
94         assertFalse(a.isCompletedAbnormally());
95         assertNull(a.getException());
96         assertNull(a.getRawResult());
97 
98         {
99             Thread.currentThread().interrupt();
100             long startTime = System.nanoTime();
101             assertNull(a.join());
102             assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
103             Thread.interrupted();
104         }
105 
106         {
107             Thread.currentThread().interrupt();
108             long startTime = System.nanoTime();
109             a.quietlyJoin();        // should be no-op
110             assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
111             Thread.interrupted();
112         }
113 
114         assertFalse(a.cancel(false));
115         assertFalse(a.cancel(true));
116         try {
117             assertNull(a.get());
118         } catch (Throwable fail) { threadUnexpectedException(fail); }
119         try {
120             assertNull(a.get(5L, SECONDS));
121         } catch (Throwable fail) { threadUnexpectedException(fail); }
122     }
123 
124     void checkCancelled(CountedCompleter a) {
125         assertTrue(a.isDone());
126         assertTrue(a.isCancelled());
127         assertFalse(a.isCompletedNormally());
128         assertTrue(a.isCompletedAbnormally());
129         assertTrue(a.getException() instanceof CancellationException);
130         assertNull(a.getRawResult());
131         assertTrue(a.cancel(false));
132         assertTrue(a.cancel(true));
133 
134         try {
135             Thread.currentThread().interrupt();
136             a.join();
137             shouldThrow();
138         } catch (CancellationException success) {
139         } catch (Throwable fail) { threadUnexpectedException(fail); }
140         Thread.interrupted();
141 
142         {
143             long startTime = System.nanoTime();
144             a.quietlyJoin();        // should be no-op
145             assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
146         }
147 
148         try {
149             a.get();
150             shouldThrow();
151         } catch (CancellationException success) {
152         } catch (Throwable fail) { threadUnexpectedException(fail); }
153 
154         try {
155             a.get(5L, SECONDS);
156             shouldThrow();
157         } catch (CancellationException success) {
158         } catch (Throwable fail) { threadUnexpectedException(fail); }
159     }
160 
161     void checkCompletedAbnormally(CountedCompleter a, Throwable t) {
162         assertTrue(a.isDone());
163         assertFalse(a.isCancelled());
164         assertFalse(a.isCompletedNormally());
165         assertTrue(a.isCompletedAbnormally());
166         assertSame(t.getClass(), a.getException().getClass());
167         assertNull(a.getRawResult());
168         assertFalse(a.cancel(false));
169         assertFalse(a.cancel(true));
170 
171         try {
172             Thread.currentThread().interrupt();
173             a.join();
174             shouldThrow();
175         } catch (Throwable expected) {
176             assertSame(t.getClass(), expected.getClass());
177         }
178         Thread.interrupted();
179 
180         {
181             long startTime = System.nanoTime();
182             a.quietlyJoin();        // should be no-op
183             assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
184         }
185 
186         try {
187             a.get();
188             shouldThrow();
189         } catch (ExecutionException success) {
190             assertSame(t.getClass(), success.getCause().getClass());
191         } catch (Throwable fail) { threadUnexpectedException(fail); }
192 
193         try {
194             a.get(5L, SECONDS);
195             shouldThrow();
196         } catch (ExecutionException success) {
197             assertSame(t.getClass(), success.getCause().getClass());
198         } catch (Throwable fail) { threadUnexpectedException(fail); }
199 
200         try {
201             a.invoke();
202             shouldThrow();
203         } catch (Throwable success) {
204             assertSame(t, success);
205         }
206     }
207 
208     public static final class FJException extends RuntimeException {
209         FJException() { super(); }
210     }
211 
212     abstract class CheckedCC extends CountedCompleter<Object> {
213         final AtomicInteger computeN = new AtomicInteger(0);
214         final AtomicInteger onCompletionN = new AtomicInteger(0);
215         final AtomicInteger onExceptionalCompletionN = new AtomicInteger(0);
216         final AtomicInteger setRawResultN = new AtomicInteger(0);
217         final AtomicReference<Object> rawResult = new AtomicReference<Object>(null);
218         int computeN() { return computeN.get(); }
219         int onCompletionN() { return onCompletionN.get(); }
220         int onExceptionalCompletionN() { return onExceptionalCompletionN.get(); }
221         int setRawResultN() { return setRawResultN.get(); }
222 
223         CheckedCC() { super(); }
224         CheckedCC(CountedCompleter p) { super(p); }
225         CheckedCC(CountedCompleter p, int n) { super(p, n); }
226         abstract void realCompute();
227         public final void compute() {
228             computeN.incrementAndGet();
229             realCompute();
230         }
231         public void onCompletion(CountedCompleter caller) {
232             onCompletionN.incrementAndGet();
233             super.onCompletion(caller);
234         }
235         public boolean onExceptionalCompletion(Throwable ex,
236                                                CountedCompleter caller) {
237             onExceptionalCompletionN.incrementAndGet();
238             assertNotNull(ex);
239             assertTrue(isCompletedAbnormally());
240             assertTrue(super.onExceptionalCompletion(ex, caller));
241             return true;
242         }
243         protected void setRawResult(Object t) {
244             setRawResultN.incrementAndGet();
245             rawResult.set(t);
246             super.setRawResult(t);
247         }
248         void checkIncomplete() {
249             assertEquals(0, computeN());
250             assertEquals(0, onCompletionN());
251             assertEquals(0, onExceptionalCompletionN());
252             assertEquals(0, setRawResultN());
253             checkNotDone(this);
254         }
255         void checkCompletes(Object rawResult) {
256             checkIncomplete();
257             int pendingCount = getPendingCount();
258             complete(rawResult);
259             assertEquals(pendingCount, getPendingCount());
260             assertEquals(0, computeN());
261             assertEquals(1, onCompletionN());
262             assertEquals(0, onExceptionalCompletionN());
263             assertEquals(1, setRawResultN());
264             assertSame(rawResult, this.rawResult.get());
265             checkCompletedNormally(this);
266         }
267         void checkCompletesExceptionally(Throwable ex) {
268             checkIncomplete();
269             completeExceptionally(ex);
270             checkCompletedExceptionally(ex);
271         }
272         void checkCompletedExceptionally(Throwable ex) {
273             assertEquals(0, computeN());
274             assertEquals(0, onCompletionN());
275             assertEquals(1, onExceptionalCompletionN());
276             assertEquals(0, setRawResultN());
277             assertNull(this.rawResult.get());
278             checkCompletedAbnormally(this, ex);
279         }
280     }
281 
282     final class NoopCC extends CheckedCC {
283         NoopCC() { super(); }
284         NoopCC(CountedCompleter p) { super(p); }
285         NoopCC(CountedCompleter p, int initialPendingCount) {
286             super(p, initialPendingCount);
287         }
288         protected void realCompute() {}
289     }
290 
291     /**
292      * A newly constructed CountedCompleter is not completed;
293      * complete() causes completion. pendingCount is ignored.
294      */
295     public void testComplete() {
296         for (Object x : new Object[] { Boolean.TRUE, null }) {
297             for (int pendingCount : new int[] { 0, 42 }) {
298                 testComplete(new NoopCC(), x, pendingCount);
299                 testComplete(new NoopCC(new NoopCC()), x, pendingCount);
300             }
301         }
302     }
303     void testComplete(NoopCC cc, Object x, int pendingCount) {
304         cc.setPendingCount(pendingCount);
305         cc.checkCompletes(x);
306         assertEquals(pendingCount, cc.getPendingCount());
307     }
308 
309     /**
310      * completeExceptionally completes exceptionally
311      */
312     public void testCompleteExceptionally() {
313         new NoopCC()
314             .checkCompletesExceptionally(new FJException());
315         new NoopCC(new NoopCC())
316             .checkCompletesExceptionally(new FJException());
317     }
318 
319     /**
320      * completeExceptionally(null) surprisingly has the same effect as
321      * completeExceptionally(new RuntimeException())
322      */
323     public void testCompleteExceptionally_null() {
324         NoopCC a = new NoopCC();
325         a.completeExceptionally(null);
326         try {
327             a.invoke();
328             shouldThrow();
329         } catch (RuntimeException success) {
330             assertSame(success.getClass(), RuntimeException.class);
331             assertNull(success.getCause());
332             a.checkCompletedExceptionally(success);
333         }
334     }
335 
336     /**
337      * setPendingCount sets the reported pending count
338      */
339     public void testSetPendingCount() {
340         NoopCC a = new NoopCC();
341         assertEquals(0, a.getPendingCount());
342         int[] vals = {
343              -1, 0, 1,
344              Integer.MIN_VALUE,
345              Integer.MAX_VALUE,
346         };
347         for (int val : vals) {
348             a.setPendingCount(val);
349             assertEquals(val, a.getPendingCount());
350         }
351     }
352 
353     /**
354      * addToPendingCount adds to the reported pending count
355      */
356     public void testAddToPendingCount() {
357         NoopCC a = new NoopCC();
358         assertEquals(0, a.getPendingCount());
359         a.addToPendingCount(1);
360         assertEquals(1, a.getPendingCount());
361         a.addToPendingCount(27);
362         assertEquals(28, a.getPendingCount());
363         a.addToPendingCount(-28);
364         assertEquals(0, a.getPendingCount());
365     }
366 
367     /**
368      * decrementPendingCountUnlessZero decrements reported pending
369      * count unless zero
370      */
371     public void testDecrementPendingCountUnlessZero() {
372         NoopCC a = new NoopCC(null, 2);
373         assertEquals(2, a.getPendingCount());
374         assertEquals(2, a.decrementPendingCountUnlessZero());
375         assertEquals(1, a.getPendingCount());
376         assertEquals(1, a.decrementPendingCountUnlessZero());
377         assertEquals(0, a.getPendingCount());
378         assertEquals(0, a.decrementPendingCountUnlessZero());
379         assertEquals(0, a.getPendingCount());
380         a.setPendingCount(-1);
381         assertEquals(-1, a.decrementPendingCountUnlessZero());
382         assertEquals(-2, a.getPendingCount());
383     }
384 
385     /**
386      * compareAndSetPendingCount compares and sets the reported
387      * pending count
388      */
389     public void testCompareAndSetPendingCount() {
390         NoopCC a = new NoopCC();
391         assertEquals(0, a.getPendingCount());
392         assertTrue(a.compareAndSetPendingCount(0, 1));
393         assertEquals(1, a.getPendingCount());
394         assertTrue(a.compareAndSetPendingCount(1, 2));
395         assertEquals(2, a.getPendingCount());
396         assertFalse(a.compareAndSetPendingCount(1, 3));
397         assertEquals(2, a.getPendingCount());
398     }
399 
400     /**
401      * getCompleter returns parent or null if at root
402      */
403     public void testGetCompleter() {
404         NoopCC a = new NoopCC();
405         assertNull(a.getCompleter());
406         CountedCompleter b = new NoopCC(a);
407         assertSame(a, b.getCompleter());
408         CountedCompleter c = new NoopCC(b);
409         assertSame(b, c.getCompleter());
410     }
411 
412     /**
413      * getRoot returns self if no parent, else parent's root
414      */
415     public void testGetRoot() {
416         NoopCC a = new NoopCC();
417         NoopCC b = new NoopCC(a);
418         NoopCC c = new NoopCC(b);
419         assertSame(a, a.getRoot());
420         assertSame(a, b.getRoot());
421         assertSame(a, c.getRoot());
422     }
423 
424     /**
425      * tryComplete decrements pending count unless zero, in which case
426      * causes completion
427      */
428     public void testTryComplete() {
429         NoopCC a = new NoopCC();
430         assertEquals(0, a.getPendingCount());
431         int n = 3;
432         a.setPendingCount(n);
433         for (; n > 0; n--) {
434             assertEquals(n, a.getPendingCount());
435             a.tryComplete();
436             a.checkIncomplete();
437             assertEquals(n - 1, a.getPendingCount());
438         }
439         a.tryComplete();
440         assertEquals(0, a.computeN());
441         assertEquals(1, a.onCompletionN());
442         assertEquals(0, a.onExceptionalCompletionN());
443         assertEquals(0, a.setRawResultN());
444         checkCompletedNormally(a);
445     }
446 
447     /**
448      * propagateCompletion decrements pending count unless zero, in
449      * which case causes completion, without invoking onCompletion
450      */
451     public void testPropagateCompletion() {
452         NoopCC a = new NoopCC();
453         assertEquals(0, a.getPendingCount());
454         int n = 3;
455         a.setPendingCount(n);
456         for (; n > 0; n--) {
457             assertEquals(n, a.getPendingCount());
458             a.propagateCompletion();
459             a.checkIncomplete();
460             assertEquals(n - 1, a.getPendingCount());
461         }
462         a.propagateCompletion();
463         assertEquals(0, a.computeN());
464         assertEquals(0, a.onCompletionN());
465         assertEquals(0, a.onExceptionalCompletionN());
466         assertEquals(0, a.setRawResultN());
467         checkCompletedNormally(a);
468     }
469 
470     /**
471      * firstComplete returns this if pending count is zero else null
472      */
473     public void testFirstComplete() {
474         NoopCC a = new NoopCC();
475         a.setPendingCount(1);
476         assertNull(a.firstComplete());
477         a.checkIncomplete();
478         assertSame(a, a.firstComplete());
479         a.checkIncomplete();
480     }
481 
482     /**
483      * firstComplete.nextComplete returns parent if pending count is
484      * zero else null
485      */
486     public void testNextComplete() {
487         NoopCC a = new NoopCC();
488         NoopCC b = new NoopCC(a);
489         a.setPendingCount(1);
490         b.setPendingCount(1);
491         assertNull(b.firstComplete());
492         assertSame(b, b.firstComplete());
493         assertNull(b.nextComplete());
494         a.checkIncomplete();
495         b.checkIncomplete();
496         assertSame(a, b.nextComplete());
497         assertSame(a, b.nextComplete());
498         a.checkIncomplete();
499         b.checkIncomplete();
500         assertNull(a.nextComplete());
501         b.checkIncomplete();
502         checkCompletedNormally(a);
503     }
504 
505     /**
506      * quietlyCompleteRoot completes root task and only root task
507      */
508     public void testQuietlyCompleteRoot() {
509         NoopCC a = new NoopCC();
510         NoopCC b = new NoopCC(a);
511         NoopCC c = new NoopCC(b);
512         a.setPendingCount(1);
513         b.setPendingCount(1);
514         c.setPendingCount(1);
515         c.quietlyCompleteRoot();
516         assertTrue(a.isDone());
517         assertFalse(b.isDone());
518         assertFalse(c.isDone());
519     }
520 
521     // Invocation tests use some interdependent task classes
522     // to better test propagation etc
523 
524     /**
525      * Version of Fibonacci with different classes for left vs right forks
526      */
527     abstract class CCF extends CheckedCC {
528         int number;
529         int rnumber;
530 
531         public CCF(CountedCompleter parent, int n) {
532             super(parent, 1);
533             this.number = n;
534         }
535 
536         protected final void realCompute() {
537             CCF f = this;
538             int n = number;
539             while (n >= 2) {
540                 new RCCF(f, n - 2).fork();
541                 f = new LCCF(f, --n);
542             }
543             f.complete(null);
544         }
545     }
546 
547     final class LCCF extends CCF {
548         public LCCF(int n) { this(null, n); }
549         public LCCF(CountedCompleter parent, int n) {
550             super(parent, n);
551         }
552         public final void onCompletion(CountedCompleter caller) {
553             super.onCompletion(caller);
554             CCF p = (CCF)getCompleter();
555             int n = number + rnumber;
556             if (p != null)
557                 p.number = n;
558             else
559                 number = n;
560         }
561     }
562     final class RCCF extends CCF {
563         public RCCF(CountedCompleter parent, int n) {
564             super(parent, n);
565         }
566         public final void onCompletion(CountedCompleter caller) {
567             super.onCompletion(caller);
568             CCF p = (CCF)getCompleter();
569             int n = number + rnumber;
570             if (p != null)
571                 p.rnumber = n;
572             else
573                 number = n;
574         }
575     }
576 
577     // Version of CCF with forced failure in left completions
578     abstract class FailingCCF extends CheckedCC {
579         int number;
580         int rnumber;
581 
582         public FailingCCF(CountedCompleter parent, int n) {
583             super(parent, 1);
584             this.number = n;
585         }
586 
587         protected final void realCompute() {
588             FailingCCF f = this;
589             int n = number;
590             while (n >= 2) {
591                 new RFCCF(f, n - 2).fork();
592                 f = new LFCCF(f, --n);
593             }
594             f.complete(null);
595         }
596     }
597 
598     final class LFCCF extends FailingCCF {
LFCCF(int n)599         public LFCCF(int n) { this(null, n); }
LFCCF(CountedCompleter parent, int n)600         public LFCCF(CountedCompleter parent, int n) {
601             super(parent, n);
602         }
onCompletion(CountedCompleter caller)603         public final void onCompletion(CountedCompleter caller) {
604             super.onCompletion(caller);
605             FailingCCF p = (FailingCCF)getCompleter();
606             int n = number + rnumber;
607             if (p != null)
608                 p.number = n;
609             else
610                 number = n;
611         }
612     }
613     final class RFCCF extends FailingCCF {
RFCCF(CountedCompleter parent, int n)614         public RFCCF(CountedCompleter parent, int n) {
615             super(parent, n);
616         }
onCompletion(CountedCompleter caller)617         public final void onCompletion(CountedCompleter caller) {
618             super.onCompletion(caller);
619             completeExceptionally(new FJException());
620         }
621     }
622 
623     /**
624      * invoke returns when task completes normally.
625      * isCompletedAbnormally and isCancelled return false for normally
626      * completed tasks; getRawResult returns null.
627      */
testInvoke()628     public void testInvoke() {
629         ForkJoinTask a = new CheckedRecursiveAction() {
630             protected void realCompute() {
631                 CCF f = new LCCF(8);
632                 assertNull(f.invoke());
633                 assertEquals(21, f.number);
634                 checkCompletedNormally(f);
635             }};
636         testInvokeOnPool(mainPool(), a);
637     }
638 
639     /**
640      * quietlyInvoke task returns when task completes normally.
641      * isCompletedAbnormally and isCancelled return false for normally
642      * completed tasks
643      */
testQuietlyInvoke()644     public void testQuietlyInvoke() {
645         ForkJoinTask a = new CheckedRecursiveAction() {
646             protected void realCompute() {
647                 CCF f = new LCCF(8);
648                 f.quietlyInvoke();
649                 assertEquals(21, f.number);
650                 checkCompletedNormally(f);
651             }};
652         testInvokeOnPool(mainPool(), a);
653     }
654 
655     /**
656      * join of a forked task returns when task completes
657      */
testForkJoin()658     public void testForkJoin() {
659         ForkJoinTask a = new CheckedRecursiveAction() {
660             protected void realCompute() {
661                 CCF f = new LCCF(8);
662                 assertSame(f, f.fork());
663                 assertNull(f.join());
664                 assertEquals(21, f.number);
665                 checkCompletedNormally(f);
666             }};
667         testInvokeOnPool(mainPool(), a);
668     }
669 
670     /**
671      * get of a forked task returns when task completes
672      */
testForkGet()673     public void testForkGet() {
674         ForkJoinTask a = new CheckedRecursiveAction() {
675             protected void realCompute() throws Exception {
676                 CCF f = new LCCF(8);
677                 assertSame(f, f.fork());
678                 assertNull(f.get());
679                 assertEquals(21, f.number);
680                 checkCompletedNormally(f);
681             }};
682         testInvokeOnPool(mainPool(), a);
683     }
684 
685     /**
686      * timed get of a forked task returns when task completes
687      */
testForkTimedGet()688     public void testForkTimedGet() {
689         ForkJoinTask a = new CheckedRecursiveAction() {
690             protected void realCompute() throws Exception {
691                 CCF f = new LCCF(8);
692                 assertSame(f, f.fork());
693                 assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
694                 assertEquals(21, f.number);
695                 checkCompletedNormally(f);
696             }};
697         testInvokeOnPool(mainPool(), a);
698     }
699 
700     /**
701      * timed get with null time unit throws NPE
702      */
testForkTimedGetNPE()703     public void testForkTimedGetNPE() {
704         ForkJoinTask a = new CheckedRecursiveAction() {
705             protected void realCompute() throws Exception {
706                 CCF f = new LCCF(8);
707                 assertSame(f, f.fork());
708                 try {
709                     f.get(5L, null);
710                     shouldThrow();
711                 } catch (NullPointerException success) {}
712             }};
713         testInvokeOnPool(mainPool(), a);
714     }
715 
716     /**
717      * quietlyJoin of a forked task returns when task completes
718      */
testForkQuietlyJoin()719     public void testForkQuietlyJoin() {
720         ForkJoinTask a = new CheckedRecursiveAction() {
721             protected void realCompute() {
722                 CCF f = new LCCF(8);
723                 assertSame(f, f.fork());
724                 f.quietlyJoin();
725                 assertEquals(21, f.number);
726                 checkCompletedNormally(f);
727             }};
728         testInvokeOnPool(mainPool(), a);
729     }
730 
731     /**
732      * helpQuiesce returns when tasks are complete.
733      * getQueuedTaskCount returns 0 when quiescent
734      */
testForkHelpQuiesce()735     public void testForkHelpQuiesce() {
736         ForkJoinTask a = new CheckedRecursiveAction() {
737             protected void realCompute() {
738                 CCF f = new LCCF(8);
739                 assertSame(f, f.fork());
740                 helpQuiesce();
741                 assertEquals(21, f.number);
742                 assertEquals(0, getQueuedTaskCount());
743                 checkCompletedNormally(f);
744             }};
745         testInvokeOnPool(mainPool(), a);
746     }
747 
748     /**
749      * invoke task throws exception when task completes abnormally
750      */
testAbnormalInvoke()751     public void testAbnormalInvoke() {
752         ForkJoinTask a = new CheckedRecursiveAction() {
753             protected void realCompute() {
754                 FailingCCF f = new LFCCF(8);
755                 try {
756                     f.invoke();
757                     shouldThrow();
758                 } catch (FJException success) {
759                     checkCompletedAbnormally(f, success);
760                 }
761             }};
762         testInvokeOnPool(mainPool(), a);
763     }
764 
765     /**
766      * quietlyInvoke task returns when task completes abnormally
767      */
testAbnormalQuietlyInvoke()768     public void testAbnormalQuietlyInvoke() {
769         ForkJoinTask a = new CheckedRecursiveAction() {
770             protected void realCompute() {
771                 FailingCCF f = new LFCCF(8);
772                 f.quietlyInvoke();
773                 assertTrue(f.getException() instanceof FJException);
774                 checkCompletedAbnormally(f, f.getException());
775             }};
776         testInvokeOnPool(mainPool(), a);
777     }
778 
779     /**
780      * join of a forked task throws exception when task completes abnormally
781      */
testAbnormalForkJoin()782     public void testAbnormalForkJoin() {
783         ForkJoinTask a = new CheckedRecursiveAction() {
784             protected void realCompute() {
785                 FailingCCF f = new LFCCF(8);
786                 assertSame(f, f.fork());
787                 try {
788                     f.join();
789                     shouldThrow();
790                 } catch (FJException success) {
791                     checkCompletedAbnormally(f, success);
792                 }
793             }};
794         testInvokeOnPool(mainPool(), a);
795     }
796 
797     /**
798      * get of a forked task throws exception when task completes abnormally
799      */
testAbnormalForkGet()800     public void testAbnormalForkGet() {
801         ForkJoinTask a = new CheckedRecursiveAction() {
802             protected void realCompute() throws Exception {
803                 FailingCCF f = new LFCCF(8);
804                 assertSame(f, f.fork());
805                 try {
806                     f.get();
807                     shouldThrow();
808                 } catch (ExecutionException success) {
809                     Throwable cause = success.getCause();
810                     assertTrue(cause instanceof FJException);
811                     checkCompletedAbnormally(f, cause);
812                 }
813             }};
814         testInvokeOnPool(mainPool(), a);
815     }
816 
817     /**
818      * timed get of a forked task throws exception when task completes abnormally
819      */
testAbnormalForkTimedGet()820     public void testAbnormalForkTimedGet() {
821         ForkJoinTask a = new CheckedRecursiveAction() {
822             protected void realCompute() throws Exception {
823                 FailingCCF f = new LFCCF(8);
824                 assertSame(f, f.fork());
825                 try {
826                     f.get(LONG_DELAY_MS, MILLISECONDS);
827                     shouldThrow();
828                 } catch (ExecutionException success) {
829                     Throwable cause = success.getCause();
830                     assertTrue(cause instanceof FJException);
831                     checkCompletedAbnormally(f, cause);
832                 }
833             }};
834         testInvokeOnPool(mainPool(), a);
835     }
836 
837     /**
838      * quietlyJoin of a forked task returns when task completes abnormally
839      */
testAbnormalForkQuietlyJoin()840     public void testAbnormalForkQuietlyJoin() {
841         ForkJoinTask a = new CheckedRecursiveAction() {
842             protected void realCompute() {
843                 FailingCCF f = new LFCCF(8);
844                 assertSame(f, f.fork());
845                 f.quietlyJoin();
846                 assertTrue(f.getException() instanceof FJException);
847                 checkCompletedAbnormally(f, f.getException());
848             }};
849         testInvokeOnPool(mainPool(), a);
850     }
851 
852     /**
853      * invoke task throws exception when task cancelled
854      */
testCancelledInvoke()855     public void testCancelledInvoke() {
856         ForkJoinTask a = new CheckedRecursiveAction() {
857             protected void realCompute() {
858                 CCF f = new LCCF(8);
859                 assertTrue(f.cancel(true));
860                 try {
861                     f.invoke();
862                     shouldThrow();
863                 } catch (CancellationException success) {
864                     checkCancelled(f);
865                 }
866             }};
867         testInvokeOnPool(mainPool(), a);
868     }
869 
870     /**
871      * join of a forked task throws exception when task cancelled
872      */
testCancelledForkJoin()873     public void testCancelledForkJoin() {
874         ForkJoinTask a = new CheckedRecursiveAction() {
875             protected void realCompute() {
876                 CCF f = new LCCF(8);
877                 assertTrue(f.cancel(true));
878                 assertSame(f, f.fork());
879                 try {
880                     f.join();
881                     shouldThrow();
882                 } catch (CancellationException success) {
883                     checkCancelled(f);
884                 }
885             }};
886         testInvokeOnPool(mainPool(), a);
887     }
888 
889     /**
890      * get of a forked task throws exception when task cancelled
891      */
testCancelledForkGet()892     public void testCancelledForkGet() {
893         ForkJoinTask a = new CheckedRecursiveAction() {
894             protected void realCompute() throws Exception {
895                 CCF f = new LCCF(8);
896                 assertTrue(f.cancel(true));
897                 assertSame(f, f.fork());
898                 try {
899                     f.get();
900                     shouldThrow();
901                 } catch (CancellationException success) {
902                     checkCancelled(f);
903                 }
904             }};
905         testInvokeOnPool(mainPool(), a);
906     }
907 
908     /**
909      * timed get of a forked task throws exception when task cancelled
910      */
testCancelledForkTimedGet()911     public void testCancelledForkTimedGet() throws Exception {
912         ForkJoinTask a = new CheckedRecursiveAction() {
913             protected void realCompute() throws Exception {
914                 CCF f = new LCCF(8);
915                 assertTrue(f.cancel(true));
916                 assertSame(f, f.fork());
917                 try {
918                     f.get(LONG_DELAY_MS, MILLISECONDS);
919                     shouldThrow();
920                 } catch (CancellationException success) {
921                     checkCancelled(f);
922                 }
923             }};
924         testInvokeOnPool(mainPool(), a);
925     }
926 
927     /**
928      * quietlyJoin of a forked task returns when task cancelled
929      */
testCancelledForkQuietlyJoin()930     public void testCancelledForkQuietlyJoin() {
931         ForkJoinTask a = new CheckedRecursiveAction() {
932             protected void realCompute() {
933                 CCF f = new LCCF(8);
934                 assertTrue(f.cancel(true));
935                 assertSame(f, f.fork());
936                 f.quietlyJoin();
937                 checkCancelled(f);
938             }};
939         testInvokeOnPool(mainPool(), a);
940     }
941 
942     /**
943      * getPool of executing task returns its pool
944      */
testGetPool()945     public void testGetPool() {
946         final ForkJoinPool mainPool = mainPool();
947         ForkJoinTask a = new CheckedRecursiveAction() {
948             protected void realCompute() {
949                 assertSame(mainPool, getPool());
950             }};
951         testInvokeOnPool(mainPool, a);
952     }
953 
954     /**
955      * getPool of non-FJ task returns null
956      */
testGetPool2()957     public void testGetPool2() {
958         ForkJoinTask a = new CheckedRecursiveAction() {
959             protected void realCompute() {
960                 assertNull(getPool());
961             }};
962         assertNull(a.invoke());
963     }
964 
965     /**
966      * inForkJoinPool of executing task returns true
967      */
testInForkJoinPool()968     public void testInForkJoinPool() {
969         ForkJoinTask a = new CheckedRecursiveAction() {
970             protected void realCompute() {
971                 assertTrue(inForkJoinPool());
972             }};
973         testInvokeOnPool(mainPool(), a);
974     }
975 
976     /**
977      * inForkJoinPool of non-FJ task returns false
978      */
testInForkJoinPool2()979     public void testInForkJoinPool2() {
980         ForkJoinTask a = new CheckedRecursiveAction() {
981             protected void realCompute() {
982                 assertFalse(inForkJoinPool());
983             }};
984         assertNull(a.invoke());
985     }
986 
987     /**
988      * setRawResult(null) succeeds
989      */
testSetRawResult()990     public void testSetRawResult() {
991         ForkJoinTask a = new CheckedRecursiveAction() {
992             protected void realCompute() {
993                 setRawResult(null);
994                 assertNull(getRawResult());
995             }};
996         assertNull(a.invoke());
997     }
998 
999     /**
1000      * invoke task throws exception after invoking completeExceptionally
1001      */
testCompleteExceptionally2()1002     public void testCompleteExceptionally2() {
1003         ForkJoinTask a = new CheckedRecursiveAction() {
1004             protected void realCompute() {
1005                 CCF n = new LCCF(8);
1006                 CCF f = new LCCF(n, 8);
1007                 FJException ex = new FJException();
1008                 f.completeExceptionally(ex);
1009                 f.checkCompletedExceptionally(ex);
1010                 n.checkCompletedExceptionally(ex);
1011             }};
1012         testInvokeOnPool(mainPool(), a);
1013     }
1014 
1015     /**
1016      * invokeAll(t1, t2) invokes all task arguments
1017      */
testInvokeAll2()1018     public void testInvokeAll2() {
1019         ForkJoinTask a = new CheckedRecursiveAction() {
1020             protected void realCompute() {
1021                 CCF f = new LCCF(8);
1022                 CCF g = new LCCF(9);
1023                 invokeAll(f, g);
1024                 assertEquals(21, f.number);
1025                 assertEquals(34, g.number);
1026                 checkCompletedNormally(f);
1027                 checkCompletedNormally(g);
1028             }};
1029         testInvokeOnPool(mainPool(), a);
1030     }
1031 
1032     /**
1033      * invokeAll(tasks) with 1 argument invokes task
1034      */
testInvokeAll1()1035     public void testInvokeAll1() {
1036         ForkJoinTask a = new CheckedRecursiveAction() {
1037             protected void realCompute() {
1038                 CCF f = new LCCF(8);
1039                 invokeAll(f);
1040                 checkCompletedNormally(f);
1041                 assertEquals(21, f.number);
1042             }};
1043         testInvokeOnPool(mainPool(), a);
1044     }
1045 
1046     /**
1047      * invokeAll(tasks) with > 2 argument invokes tasks
1048      */
testInvokeAll3()1049     public void testInvokeAll3() {
1050         ForkJoinTask a = new CheckedRecursiveAction() {
1051             protected void realCompute() {
1052                 CCF f = new LCCF(8);
1053                 CCF g = new LCCF(9);
1054                 CCF h = new LCCF(7);
1055                 invokeAll(f, g, h);
1056                 assertEquals(21, f.number);
1057                 assertEquals(34, g.number);
1058                 assertEquals(13, h.number);
1059                 checkCompletedNormally(f);
1060                 checkCompletedNormally(g);
1061                 checkCompletedNormally(h);
1062             }};
1063         testInvokeOnPool(mainPool(), a);
1064     }
1065 
1066     /**
1067      * invokeAll(collection) invokes all tasks in the collection
1068      */
testInvokeAllCollection()1069     public void testInvokeAllCollection() {
1070         ForkJoinTask a = new CheckedRecursiveAction() {
1071             protected void realCompute() {
1072                 CCF f = new LCCF(8);
1073                 CCF g = new LCCF(9);
1074                 CCF h = new LCCF(7);
1075                 HashSet set = new HashSet();
1076                 set.add(f);
1077                 set.add(g);
1078                 set.add(h);
1079                 invokeAll(set);
1080                 assertEquals(21, f.number);
1081                 assertEquals(34, g.number);
1082                 assertEquals(13, h.number);
1083                 checkCompletedNormally(f);
1084                 checkCompletedNormally(g);
1085                 checkCompletedNormally(h);
1086             }};
1087         testInvokeOnPool(mainPool(), a);
1088     }
1089 
1090     /**
1091      * invokeAll(tasks) with any null task throws NPE
1092      */
testInvokeAllNPE()1093     public void testInvokeAllNPE() {
1094         ForkJoinTask a = new CheckedRecursiveAction() {
1095             protected void realCompute() {
1096                 CCF f = new LCCF(8);
1097                 CCF g = new LCCF(9);
1098                 CCF h = null;
1099                 try {
1100                     invokeAll(f, g, h);
1101                     shouldThrow();
1102                 } catch (NullPointerException success) {}
1103             }};
1104         testInvokeOnPool(mainPool(), a);
1105     }
1106 
1107     /**
1108      * invokeAll(t1, t2) throw exception if any task does
1109      */
testAbnormalInvokeAll2()1110     public void testAbnormalInvokeAll2() {
1111         ForkJoinTask a = new CheckedRecursiveAction() {
1112             protected void realCompute() {
1113                 CCF f = new LCCF(8);
1114                 FailingCCF g = new LFCCF(9);
1115                 try {
1116                     invokeAll(f, g);
1117                     shouldThrow();
1118                 } catch (FJException success) {
1119                     checkCompletedAbnormally(g, success);
1120                 }
1121             }};
1122         testInvokeOnPool(mainPool(), a);
1123     }
1124 
1125     /**
1126      * invokeAll(tasks) with 1 argument throws exception if task does
1127      */
testAbnormalInvokeAll1()1128     public void testAbnormalInvokeAll1() {
1129         ForkJoinTask a = new CheckedRecursiveAction() {
1130             protected void realCompute() {
1131                 FailingCCF g = new LFCCF(9);
1132                 try {
1133                     invokeAll(g);
1134                     shouldThrow();
1135                 } catch (FJException success) {
1136                     checkCompletedAbnormally(g, success);
1137                 }
1138             }};
1139         testInvokeOnPool(mainPool(), a);
1140     }
1141 
1142     /**
1143      * invokeAll(tasks) with > 2 argument throws exception if any task does
1144      */
testAbnormalInvokeAll3()1145     public void testAbnormalInvokeAll3() {
1146         ForkJoinTask a = new CheckedRecursiveAction() {
1147             protected void realCompute() {
1148                 CCF f = new LCCF(8);
1149                 FailingCCF g = new LFCCF(9);
1150                 CCF h = new LCCF(7);
1151                 try {
1152                     invokeAll(f, g, h);
1153                     shouldThrow();
1154                 } catch (FJException success) {
1155                     checkCompletedAbnormally(g, success);
1156                 }
1157             }};
1158         testInvokeOnPool(mainPool(), a);
1159     }
1160 
1161     /**
1162      * invokeAll(collection) throws exception if any task does
1163      */
testAbnormalInvokeAllCollection()1164     public void testAbnormalInvokeAllCollection() {
1165         ForkJoinTask a = new CheckedRecursiveAction() {
1166             protected void realCompute() {
1167                 FailingCCF f = new LFCCF(8);
1168                 CCF g = new LCCF(9);
1169                 CCF h = new LCCF(7);
1170                 HashSet set = new HashSet();
1171                 set.add(f);
1172                 set.add(g);
1173                 set.add(h);
1174                 try {
1175                     invokeAll(set);
1176                     shouldThrow();
1177                 } catch (FJException success) {
1178                     checkCompletedAbnormally(f, success);
1179                 }
1180             }};
1181         testInvokeOnPool(mainPool(), a);
1182     }
1183 
1184     /**
1185      * tryUnfork returns true for most recent unexecuted task,
1186      * and suppresses execution
1187      */
testTryUnfork()1188     public void testTryUnfork() {
1189         ForkJoinTask a = new CheckedRecursiveAction() {
1190             protected void realCompute() {
1191                 CCF g = new LCCF(9);
1192                 assertSame(g, g.fork());
1193                 CCF f = new LCCF(8);
1194                 assertSame(f, f.fork());
1195                 assertTrue(f.tryUnfork());
1196                 helpQuiesce();
1197                 checkNotDone(f);
1198                 checkCompletedNormally(g);
1199             }};
1200         testInvokeOnPool(singletonPool(), a);
1201     }
1202 
1203     /**
1204      * getSurplusQueuedTaskCount returns > 0 when
1205      * there are more tasks than threads
1206      */
testGetSurplusQueuedTaskCount()1207     public void testGetSurplusQueuedTaskCount() {
1208         ForkJoinTask a = new CheckedRecursiveAction() {
1209             protected void realCompute() {
1210                 CCF h = new LCCF(7);
1211                 assertSame(h, h.fork());
1212                 CCF g = new LCCF(9);
1213                 assertSame(g, g.fork());
1214                 CCF f = new LCCF(8);
1215                 assertSame(f, f.fork());
1216                 assertTrue(getSurplusQueuedTaskCount() > 0);
1217                 helpQuiesce();
1218                 assertEquals(0, getSurplusQueuedTaskCount());
1219                 checkCompletedNormally(f);
1220                 checkCompletedNormally(g);
1221                 checkCompletedNormally(h);
1222             }};
1223         testInvokeOnPool(singletonPool(), a);
1224     }
1225 
1226     /**
1227      * peekNextLocalTask returns most recent unexecuted task.
1228      */
testPeekNextLocalTask()1229     public void testPeekNextLocalTask() {
1230         ForkJoinTask a = new CheckedRecursiveAction() {
1231             protected void realCompute() {
1232                 CCF g = new LCCF(9);
1233                 assertSame(g, g.fork());
1234                 CCF f = new LCCF(8);
1235                 assertSame(f, f.fork());
1236                 assertSame(f, peekNextLocalTask());
1237                 assertNull(f.join());
1238                 checkCompletedNormally(f);
1239                 helpQuiesce();
1240                 checkCompletedNormally(g);
1241             }};
1242         testInvokeOnPool(singletonPool(), a);
1243     }
1244 
1245     /**
1246      * pollNextLocalTask returns most recent unexecuted task without
1247      * executing it
1248      */
testPollNextLocalTask()1249     public void testPollNextLocalTask() {
1250         ForkJoinTask a = new CheckedRecursiveAction() {
1251             protected void realCompute() {
1252                 CCF g = new LCCF(9);
1253                 assertSame(g, g.fork());
1254                 CCF f = new LCCF(8);
1255                 assertSame(f, f.fork());
1256                 assertSame(f, pollNextLocalTask());
1257                 helpQuiesce();
1258                 checkNotDone(f);
1259                 assertEquals(34, g.number);
1260                 checkCompletedNormally(g);
1261             }};
1262         testInvokeOnPool(singletonPool(), a);
1263     }
1264 
1265     /**
1266      * pollTask returns an unexecuted task without executing it
1267      */
testPollTask()1268     public void testPollTask() {
1269         ForkJoinTask a = new CheckedRecursiveAction() {
1270             protected void realCompute() {
1271                 CCF g = new LCCF(9);
1272                 assertSame(g, g.fork());
1273                 CCF f = new LCCF(8);
1274                 assertSame(f, f.fork());
1275                 assertSame(f, pollTask());
1276                 helpQuiesce();
1277                 checkNotDone(f);
1278                 checkCompletedNormally(g);
1279             }};
1280         testInvokeOnPool(singletonPool(), a);
1281     }
1282 
1283     /**
1284      * peekNextLocalTask returns least recent unexecuted task in async mode
1285      */
testPeekNextLocalTaskAsync()1286     public void testPeekNextLocalTaskAsync() {
1287         ForkJoinTask a = new CheckedRecursiveAction() {
1288             protected void realCompute() {
1289                 CCF g = new LCCF(9);
1290                 assertSame(g, g.fork());
1291                 CCF f = new LCCF(8);
1292                 assertSame(f, f.fork());
1293                 assertSame(g, peekNextLocalTask());
1294                 assertNull(f.join());
1295                 helpQuiesce();
1296                 checkCompletedNormally(f);
1297                 assertEquals(34, g.number);
1298                 checkCompletedNormally(g);
1299             }};
1300         testInvokeOnPool(asyncSingletonPool(), a);
1301     }
1302 
1303     /**
1304      * pollNextLocalTask returns least recent unexecuted task without
1305      * executing it, in async mode
1306      */
testPollNextLocalTaskAsync()1307     public void testPollNextLocalTaskAsync() {
1308         ForkJoinTask a = new CheckedRecursiveAction() {
1309             protected void realCompute() {
1310                 CCF g = new LCCF(9);
1311                 assertSame(g, g.fork());
1312                 CCF f = new LCCF(8);
1313                 assertSame(f, f.fork());
1314                 assertSame(g, pollNextLocalTask());
1315                 helpQuiesce();
1316                 assertEquals(21, f.number);
1317                 checkCompletedNormally(f);
1318                 checkNotDone(g);
1319             }};
1320         testInvokeOnPool(asyncSingletonPool(), a);
1321     }
1322 
1323     /**
1324      * pollTask returns an unexecuted task without executing it, in
1325      * async mode
1326      */
testPollTaskAsync()1327     public void testPollTaskAsync() {
1328         ForkJoinTask a = new CheckedRecursiveAction() {
1329             protected void realCompute() {
1330                 CCF g = new LCCF(9);
1331                 assertSame(g, g.fork());
1332                 CCF f = new LCCF(8);
1333                 assertSame(f, f.fork());
1334                 assertSame(g, pollTask());
1335                 helpQuiesce();
1336                 assertEquals(21, f.number);
1337                 checkCompletedNormally(f);
1338                 checkNotDone(g);
1339             }};
1340         testInvokeOnPool(asyncSingletonPool(), a);
1341     }
1342 
1343     // versions for singleton pools
1344 
1345     /**
1346      * invoke returns when task completes normally.
1347      * isCompletedAbnormally and isCancelled return false for normally
1348      * completed tasks; getRawResult returns null.
1349      */
testInvokeSingleton()1350     public void testInvokeSingleton() {
1351         ForkJoinTask a = new CheckedRecursiveAction() {
1352             protected void realCompute() {
1353                 CCF f = new LCCF(8);
1354                 assertNull(f.invoke());
1355                 assertEquals(21, f.number);
1356                 checkCompletedNormally(f);
1357             }};
1358         testInvokeOnPool(singletonPool(), a);
1359     }
1360 
1361     /**
1362      * quietlyInvoke task returns when task completes normally.
1363      * isCompletedAbnormally and isCancelled return false for normally
1364      * completed tasks
1365      */
testQuietlyInvokeSingleton()1366     public void testQuietlyInvokeSingleton() {
1367         ForkJoinTask a = new CheckedRecursiveAction() {
1368             protected void realCompute() {
1369                 CCF f = new LCCF(8);
1370                 f.quietlyInvoke();
1371                 assertEquals(21, f.number);
1372                 checkCompletedNormally(f);
1373             }};
1374         testInvokeOnPool(singletonPool(), a);
1375     }
1376 
1377     /**
1378      * join of a forked task returns when task completes
1379      */
testForkJoinSingleton()1380     public void testForkJoinSingleton() {
1381         ForkJoinTask a = new CheckedRecursiveAction() {
1382             protected void realCompute() {
1383                 CCF f = new LCCF(8);
1384                 assertSame(f, f.fork());
1385                 assertNull(f.join());
1386                 assertEquals(21, f.number);
1387                 checkCompletedNormally(f);
1388             }};
1389         testInvokeOnPool(singletonPool(), a);
1390     }
1391 
1392     /**
1393      * get of a forked task returns when task completes
1394      */
testForkGetSingleton()1395     public void testForkGetSingleton() {
1396         ForkJoinTask a = new CheckedRecursiveAction() {
1397             protected void realCompute() throws Exception {
1398                 CCF f = new LCCF(8);
1399                 assertSame(f, f.fork());
1400                 assertNull(f.get());
1401                 assertEquals(21, f.number);
1402                 checkCompletedNormally(f);
1403             }};
1404         testInvokeOnPool(singletonPool(), a);
1405     }
1406 
1407     /**
1408      * timed get of a forked task returns when task completes
1409      */
testForkTimedGetSingleton()1410     public void testForkTimedGetSingleton() {
1411         ForkJoinTask a = new CheckedRecursiveAction() {
1412             protected void realCompute() throws Exception {
1413                 CCF f = new LCCF(8);
1414                 assertSame(f, f.fork());
1415                 assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
1416                 assertEquals(21, f.number);
1417                 checkCompletedNormally(f);
1418             }};
1419         testInvokeOnPool(singletonPool(), a);
1420     }
1421 
1422     /**
1423      * timed get with null time unit throws NPE
1424      */
testForkTimedGetNPESingleton()1425     public void testForkTimedGetNPESingleton() {
1426         ForkJoinTask a = new CheckedRecursiveAction() {
1427             protected void realCompute() throws Exception {
1428                 CCF f = new LCCF(8);
1429                 assertSame(f, f.fork());
1430                 try {
1431                     f.get(5L, null);
1432                     shouldThrow();
1433                 } catch (NullPointerException success) {}
1434             }};
1435         testInvokeOnPool(singletonPool(), a);
1436     }
1437 
1438     /**
1439      * quietlyJoin of a forked task returns when task completes
1440      */
testForkQuietlyJoinSingleton()1441     public void testForkQuietlyJoinSingleton() {
1442         ForkJoinTask a = new CheckedRecursiveAction() {
1443             protected void realCompute() {
1444                 CCF f = new LCCF(8);
1445                 assertSame(f, f.fork());
1446                 f.quietlyJoin();
1447                 assertEquals(21, f.number);
1448                 checkCompletedNormally(f);
1449             }};
1450         testInvokeOnPool(singletonPool(), a);
1451     }
1452 
1453     /**
1454      * helpQuiesce returns when tasks are complete.
1455      * getQueuedTaskCount returns 0 when quiescent
1456      */
testForkHelpQuiesceSingleton()1457     public void testForkHelpQuiesceSingleton() {
1458         ForkJoinTask a = new CheckedRecursiveAction() {
1459             protected void realCompute() {
1460                 CCF f = new LCCF(8);
1461                 assertSame(f, f.fork());
1462                 helpQuiesce();
1463                 assertEquals(0, getQueuedTaskCount());
1464                 assertEquals(21, f.number);
1465                 checkCompletedNormally(f);
1466             }};
1467         testInvokeOnPool(singletonPool(), a);
1468     }
1469 
1470     /**
1471      * invoke task throws exception when task completes abnormally
1472      */
testAbnormalInvokeSingleton()1473     public void testAbnormalInvokeSingleton() {
1474         ForkJoinTask a = new CheckedRecursiveAction() {
1475             protected void realCompute() {
1476                 FailingCCF f = new LFCCF(8);
1477                 try {
1478                     f.invoke();
1479                     shouldThrow();
1480                 } catch (FJException success) {
1481                     checkCompletedAbnormally(f, success);
1482                 }
1483             }};
1484         testInvokeOnPool(singletonPool(), a);
1485     }
1486 
1487     /**
1488      * quietlyInvoke task returns when task completes abnormally
1489      */
testAbnormalQuietlyInvokeSingleton()1490     public void testAbnormalQuietlyInvokeSingleton() {
1491         ForkJoinTask a = new CheckedRecursiveAction() {
1492             protected void realCompute() {
1493                 FailingCCF f = new LFCCF(8);
1494                 f.quietlyInvoke();
1495                 assertTrue(f.getException() instanceof FJException);
1496                 checkCompletedAbnormally(f, f.getException());
1497             }};
1498         testInvokeOnPool(singletonPool(), a);
1499     }
1500 
1501     /**
1502      * join of a forked task throws exception when task completes abnormally
1503      */
testAbnormalForkJoinSingleton()1504     public void testAbnormalForkJoinSingleton() {
1505         ForkJoinTask a = new CheckedRecursiveAction() {
1506             protected void realCompute() {
1507                 FailingCCF f = new LFCCF(8);
1508                 assertSame(f, f.fork());
1509                 try {
1510                     f.join();
1511                     shouldThrow();
1512                 } catch (FJException success) {
1513                     checkCompletedAbnormally(f, success);
1514                 }
1515             }};
1516         testInvokeOnPool(singletonPool(), a);
1517     }
1518 
1519     /**
1520      * get of a forked task throws exception when task completes abnormally
1521      */
testAbnormalForkGetSingleton()1522     public void testAbnormalForkGetSingleton() {
1523         ForkJoinTask a = new CheckedRecursiveAction() {
1524             protected void realCompute() throws Exception {
1525                 FailingCCF f = new LFCCF(8);
1526                 assertSame(f, f.fork());
1527                 try {
1528                     f.get();
1529                     shouldThrow();
1530                 } catch (ExecutionException success) {
1531                     Throwable cause = success.getCause();
1532                     assertTrue(cause instanceof FJException);
1533                     checkCompletedAbnormally(f, cause);
1534                 }
1535             }};
1536         testInvokeOnPool(singletonPool(), a);
1537     }
1538 
1539     /**
1540      * timed get of a forked task throws exception when task completes abnormally
1541      */
testAbnormalForkTimedGetSingleton()1542     public void testAbnormalForkTimedGetSingleton() {
1543         ForkJoinTask a = new CheckedRecursiveAction() {
1544             protected void realCompute() throws Exception {
1545                 FailingCCF f = new LFCCF(8);
1546                 assertSame(f, f.fork());
1547                 try {
1548                     f.get(LONG_DELAY_MS, MILLISECONDS);
1549                     shouldThrow();
1550                 } catch (ExecutionException success) {
1551                     Throwable cause = success.getCause();
1552                     assertTrue(cause instanceof FJException);
1553                     checkCompletedAbnormally(f, cause);
1554                 }
1555             }};
1556         testInvokeOnPool(singletonPool(), a);
1557     }
1558 
1559     /**
1560      * quietlyJoin of a forked task returns when task completes abnormally
1561      */
testAbnormalForkQuietlyJoinSingleton()1562     public void testAbnormalForkQuietlyJoinSingleton() {
1563         ForkJoinTask a = new CheckedRecursiveAction() {
1564             protected void realCompute() {
1565                 FailingCCF f = new LFCCF(8);
1566                 assertSame(f, f.fork());
1567                 f.quietlyJoin();
1568                 assertTrue(f.getException() instanceof FJException);
1569                 checkCompletedAbnormally(f, f.getException());
1570             }};
1571         testInvokeOnPool(singletonPool(), a);
1572     }
1573 
1574     /**
1575      * invoke task throws exception when task cancelled
1576      */
testCancelledInvokeSingleton()1577     public void testCancelledInvokeSingleton() {
1578         ForkJoinTask a = new CheckedRecursiveAction() {
1579             protected void realCompute() {
1580                 CCF f = new LCCF(8);
1581                 assertTrue(f.cancel(true));
1582                 try {
1583                     f.invoke();
1584                     shouldThrow();
1585                 } catch (CancellationException success) {
1586                     checkCancelled(f);
1587                 }
1588             }};
1589         testInvokeOnPool(singletonPool(), a);
1590     }
1591 
1592     /**
1593      * join of a forked task throws exception when task cancelled
1594      */
testCancelledForkJoinSingleton()1595     public void testCancelledForkJoinSingleton() {
1596         ForkJoinTask a = new CheckedRecursiveAction() {
1597             protected void realCompute() {
1598                 CCF f = new LCCF(8);
1599                 assertTrue(f.cancel(true));
1600                 assertSame(f, f.fork());
1601                 try {
1602                     f.join();
1603                     shouldThrow();
1604                 } catch (CancellationException success) {
1605                     checkCancelled(f);
1606                 }
1607             }};
1608         testInvokeOnPool(singletonPool(), a);
1609     }
1610 
1611     /**
1612      * get of a forked task throws exception when task cancelled
1613      */
testCancelledForkGetSingleton()1614     public void testCancelledForkGetSingleton() {
1615         ForkJoinTask a = new CheckedRecursiveAction() {
1616             protected void realCompute() throws Exception {
1617                 CCF f = new LCCF(8);
1618                 assertTrue(f.cancel(true));
1619                 assertSame(f, f.fork());
1620                 try {
1621                     f.get();
1622                     shouldThrow();
1623                 } catch (CancellationException success) {
1624                     checkCancelled(f);
1625                 }
1626             }};
1627         testInvokeOnPool(singletonPool(), a);
1628     }
1629 
1630     /**
1631      * timed get of a forked task throws exception when task cancelled
1632      */
testCancelledForkTimedGetSingleton()1633     public void testCancelledForkTimedGetSingleton() throws Exception {
1634         ForkJoinTask a = new CheckedRecursiveAction() {
1635             protected void realCompute() throws Exception {
1636                 CCF f = new LCCF(8);
1637                 assertTrue(f.cancel(true));
1638                 assertSame(f, f.fork());
1639                 try {
1640                     f.get(LONG_DELAY_MS, MILLISECONDS);
1641                     shouldThrow();
1642                 } catch (CancellationException success) {
1643                     checkCancelled(f);
1644                 }
1645             }};
1646         testInvokeOnPool(singletonPool(), a);
1647     }
1648 
1649     /**
1650      * quietlyJoin of a forked task returns when task cancelled
1651      */
testCancelledForkQuietlyJoinSingleton()1652     public void testCancelledForkQuietlyJoinSingleton() {
1653         ForkJoinTask a = new CheckedRecursiveAction() {
1654             protected void realCompute() {
1655                 CCF f = new LCCF(8);
1656                 assertTrue(f.cancel(true));
1657                 assertSame(f, f.fork());
1658                 f.quietlyJoin();
1659                 checkCancelled(f);
1660             }};
1661         testInvokeOnPool(singletonPool(), a);
1662     }
1663 
1664     /**
1665      * invoke task throws exception after invoking completeExceptionally
1666      */
testCompleteExceptionallySingleton()1667     public void testCompleteExceptionallySingleton() {
1668         ForkJoinTask a = new CheckedRecursiveAction() {
1669             protected void realCompute() {
1670                 CCF n = new LCCF(8);
1671                 CCF f = new LCCF(n, 8);
1672                 FJException ex = new FJException();
1673                 f.completeExceptionally(ex);
1674                 f.checkCompletedExceptionally(ex);
1675                 n.checkCompletedExceptionally(ex);
1676             }};
1677         testInvokeOnPool(singletonPool(), a);
1678     }
1679 
1680     /**
1681      * invokeAll(t1, t2) invokes all task arguments
1682      */
testInvokeAll2Singleton()1683     public void testInvokeAll2Singleton() {
1684         ForkJoinTask a = new CheckedRecursiveAction() {
1685             protected void realCompute() {
1686                 CCF f = new LCCF(8);
1687                 CCF g = new LCCF(9);
1688                 invokeAll(f, g);
1689                 assertEquals(21, f.number);
1690                 assertEquals(34, g.number);
1691                 checkCompletedNormally(f);
1692                 checkCompletedNormally(g);
1693             }};
1694         testInvokeOnPool(singletonPool(), a);
1695     }
1696 
1697     /**
1698      * invokeAll(tasks) with 1 argument invokes task
1699      */
testInvokeAll1Singleton()1700     public void testInvokeAll1Singleton() {
1701         ForkJoinTask a = new CheckedRecursiveAction() {
1702             protected void realCompute() {
1703                 CCF f = new LCCF(8);
1704                 invokeAll(f);
1705                 checkCompletedNormally(f);
1706                 assertEquals(21, f.number);
1707             }};
1708         testInvokeOnPool(singletonPool(), a);
1709     }
1710 
1711     /**
1712      * invokeAll(tasks) with > 2 argument invokes tasks
1713      */
testInvokeAll3Singleton()1714     public void testInvokeAll3Singleton() {
1715         ForkJoinTask a = new CheckedRecursiveAction() {
1716             protected void realCompute() {
1717                 CCF f = new LCCF(8);
1718                 CCF g = new LCCF(9);
1719                 CCF h = new LCCF(7);
1720                 invokeAll(f, g, h);
1721                 assertEquals(21, f.number);
1722                 assertEquals(34, g.number);
1723                 assertEquals(13, h.number);
1724                 checkCompletedNormally(f);
1725                 checkCompletedNormally(g);
1726                 checkCompletedNormally(h);
1727             }};
1728         testInvokeOnPool(singletonPool(), a);
1729     }
1730 
1731     /**
1732      * invokeAll(collection) invokes all tasks in the collection
1733      */
testInvokeAllCollectionSingleton()1734     public void testInvokeAllCollectionSingleton() {
1735         ForkJoinTask a = new CheckedRecursiveAction() {
1736             protected void realCompute() {
1737                 CCF f = new LCCF(8);
1738                 CCF g = new LCCF(9);
1739                 CCF h = new LCCF(7);
1740                 HashSet set = new HashSet();
1741                 set.add(f);
1742                 set.add(g);
1743                 set.add(h);
1744                 invokeAll(set);
1745                 assertEquals(21, f.number);
1746                 assertEquals(34, g.number);
1747                 assertEquals(13, h.number);
1748                 checkCompletedNormally(f);
1749                 checkCompletedNormally(g);
1750                 checkCompletedNormally(h);
1751             }};
1752         testInvokeOnPool(singletonPool(), a);
1753     }
1754 
1755     /**
1756      * invokeAll(tasks) with any null task throws NPE
1757      */
testInvokeAllNPESingleton()1758     public void testInvokeAllNPESingleton() {
1759         ForkJoinTask a = new CheckedRecursiveAction() {
1760             protected void realCompute() {
1761                 CCF f = new LCCF(8);
1762                 CCF g = new LCCF(9);
1763                 CCF h = null;
1764                 try {
1765                     invokeAll(f, g, h);
1766                     shouldThrow();
1767                 } catch (NullPointerException success) {}
1768             }};
1769         testInvokeOnPool(singletonPool(), a);
1770     }
1771 
1772     /**
1773      * invokeAll(t1, t2) throw exception if any task does
1774      */
testAbnormalInvokeAll2Singleton()1775     public void testAbnormalInvokeAll2Singleton() {
1776         ForkJoinTask a = new CheckedRecursiveAction() {
1777             protected void realCompute() {
1778                 CCF f = new LCCF(8);
1779                 FailingCCF g = new LFCCF(9);
1780                 try {
1781                     invokeAll(f, g);
1782                     shouldThrow();
1783                 } catch (FJException success) {
1784                     checkCompletedAbnormally(g, success);
1785                 }
1786             }};
1787         testInvokeOnPool(singletonPool(), a);
1788     }
1789 
1790     /**
1791      * invokeAll(tasks) with 1 argument throws exception if task does
1792      */
testAbnormalInvokeAll1Singleton()1793     public void testAbnormalInvokeAll1Singleton() {
1794         ForkJoinTask a = new CheckedRecursiveAction() {
1795             protected void realCompute() {
1796                 FailingCCF g = new LFCCF(9);
1797                 try {
1798                     invokeAll(g);
1799                     shouldThrow();
1800                 } catch (FJException success) {
1801                     checkCompletedAbnormally(g, success);
1802                 }
1803             }};
1804         testInvokeOnPool(singletonPool(), a);
1805     }
1806 
1807     /**
1808      * invokeAll(tasks) with > 2 argument throws exception if any task does
1809      */
testAbnormalInvokeAll3Singleton()1810     public void testAbnormalInvokeAll3Singleton() {
1811         ForkJoinTask a = new CheckedRecursiveAction() {
1812             protected void realCompute() {
1813                 CCF f = new LCCF(8);
1814                 FailingCCF g = new LFCCF(9);
1815                 CCF h = new LCCF(7);
1816                 try {
1817                     invokeAll(f, g, h);
1818                     shouldThrow();
1819                 } catch (FJException success) {
1820                     checkCompletedAbnormally(g, success);
1821                 }
1822             }};
1823         testInvokeOnPool(singletonPool(), a);
1824     }
1825 
1826     /**
1827      * invokeAll(collection) throws exception if any task does
1828      */
testAbnormalInvokeAllCollectionSingleton()1829     public void testAbnormalInvokeAllCollectionSingleton() {
1830         ForkJoinTask a = new CheckedRecursiveAction() {
1831             protected void realCompute() {
1832                 FailingCCF f = new LFCCF(8);
1833                 CCF g = new LCCF(9);
1834                 CCF h = new LCCF(7);
1835                 HashSet set = new HashSet();
1836                 set.add(f);
1837                 set.add(g);
1838                 set.add(h);
1839                 try {
1840                     invokeAll(set);
1841                     shouldThrow();
1842                 } catch (FJException success) {
1843                     checkCompletedAbnormally(f, success);
1844                 }
1845             }};
1846         testInvokeOnPool(singletonPool(), a);
1847     }
1848 
1849 }
1850