ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/RecursiveTaskTest.java
Revision: 1.7
Committed: Wed Aug 5 01:17:31 2009 UTC (14 years, 9 months ago) by jsr166
Branch: MAIN
Changes since 1.6: +512 -512 lines
Log Message: 
whitespace

File Contents

# User Rev Content
1 dl 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
5     */
6     import junit.framework.*;
7     import java.util.concurrent.*;
8     import java.util.*;
9    
10    
11     public class RecursiveTaskTest extends JSR166TestCase {
12    
13     public static void main(String[] args) {
14 jsr166 1.2 junit.textui.TestRunner.run (suite());
15 dl 1.1 }
16     public static Test suite() {
17     return new TestSuite(RecursiveTaskTest.class);
18     }
19    
20     static final ForkJoinPool mainPool = new ForkJoinPool();
21     static final ForkJoinPool singletonPool = new ForkJoinPool(1);
22     static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
23     static {
24     asyncSingletonPool.setAsyncMode(true);
25     }
26    
27     static final class FJException extends RuntimeException {
28     FJException() { super(); }
29     }
30    
31     // An invalid return value for Fib
32     static final Integer NoResult = Integer.valueOf(-17);
33    
34     // A simple recursive task for testing
35 jsr166 1.2 static final class FibTask extends RecursiveTask<Integer> {
36 dl 1.1 final int number;
37     FibTask(int n) { number = n; }
38     public Integer compute() {
39     int n = number;
40     if (n <= 1)
41     return n;
42     FibTask f1 = new FibTask(n - 1);
43     f1.fork();
44     return (new FibTask(n - 2)).compute() + f1.join();
45     }
46     }
47    
48     // A recursive action failing in base case
49 jsr166 1.2 static final class FailingFibTask extends RecursiveTask<Integer> {
50 dl 1.1 final int number;
51     int result;
52     FailingFibTask(int n) { number = n; }
53     public Integer compute() {
54     int n = number;
55     if (n <= 1)
56     throw new FJException();
57     FailingFibTask f1 = new FailingFibTask(n - 1);
58     f1.fork();
59     return (new FibTask(n - 2)).compute() + f1.join();
60     }
61     }
62    
63 jsr166 1.2 /**
64 dl 1.1 * invoke returns value when task completes normally.
65     * isCompletedAbnormally and isCancelled return false for normally
66     * completed tasks. getRawResult of a completed non-null task
67     * returns value;
68 jsr166 1.2 *
69 dl 1.1 */
70     public void testInvoke() {
71     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
72 jsr166 1.7 public Integer compute() {
73     FibTask f = new FibTask(8);
74     Integer r = f.invoke();
75     threadAssertTrue(r == 21);
76     threadAssertTrue(f.isDone());
77     threadAssertFalse(f.isCancelled());
78     threadAssertFalse(f.isCompletedAbnormally());
79     threadAssertTrue(f.getRawResult() == 21);
80     return r;
81     }
82     };
83 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
84     }
85    
86 jsr166 1.2 /**
87 dl 1.1 * quietlyInvoke task returns when task completes normally.
88     * isCompletedAbnormally and isCancelled return false for normally
89     * completed tasks
90     */
91     public void testQuietlyInvoke() {
92     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
93 jsr166 1.7 public Integer compute() {
94     FibTask f = new FibTask(8);
95     f.quietlyInvoke();
96     Integer r = f.getRawResult();
97     threadAssertTrue(r == 21);
98     threadAssertTrue(f.isDone());
99     threadAssertFalse(f.isCancelled());
100     threadAssertFalse(f.isCompletedAbnormally());
101     return r;
102     }
103     };
104 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
105     }
106    
107 jsr166 1.2 /**
108 dl 1.1 * join of a forked task returns when task completes
109     */
110     public void testForkJoin() {
111     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
112 jsr166 1.7 public Integer compute() {
113     FibTask f = new FibTask(8);
114     f.fork();
115     Integer r = f.join();
116     threadAssertTrue(r == 21);
117     threadAssertTrue(f.isDone());
118     return r;
119     }
120     };
121 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
122     }
123    
124 jsr166 1.2 /**
125 dl 1.1 * get of a forked task returns when task completes
126     */
127     public void testForkGet() {
128     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
129 jsr166 1.7 public Integer compute() {
130     try {
131     FibTask f = new FibTask(8);
132     f.fork();
133     Integer r = f.get();
134     threadAssertTrue(r == 21);
135     threadAssertTrue(f.isDone());
136     return r;
137     } catch (Exception ex) {
138     unexpectedException(ex);
139 dl 1.1 }
140 jsr166 1.7 return NoResult;
141     }
142     };
143 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
144     }
145    
146 jsr166 1.2 /**
147 dl 1.1 * timed get of a forked task returns when task completes
148     */
149     public void testForkTimedGet() {
150     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
151 jsr166 1.7 public Integer compute() {
152     try {
153     FibTask f = new FibTask(8);
154     f.fork();
155     Integer r = f.get(5L, TimeUnit.SECONDS);
156     threadAssertTrue(r == 21);
157     threadAssertTrue(f.isDone());
158     return r;
159     } catch (Exception ex) {
160     unexpectedException(ex);
161 dl 1.1 }
162 jsr166 1.7 return NoResult;
163     }
164     };
165 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
166     }
167    
168 jsr166 1.2 /**
169 dl 1.1 * helpJoin of a forked task returns when task completes
170     */
171     public void testForkHelpJoin() {
172     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
173 jsr166 1.7 public Integer compute() {
174     FibTask f = new FibTask(8);
175     f.fork();
176     Integer r = f.helpJoin();
177     threadAssertTrue(r == 21);
178     threadAssertTrue(f.isDone());
179     return r;
180     }
181     };
182 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
183     }
184    
185 jsr166 1.2 /**
186 dl 1.1 * quietlyJoin of a forked task returns when task completes
187     */
188     public void testForkQuietlyJoin() {
189     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
190 jsr166 1.7 public Integer compute() {
191     FibTask f = new FibTask(8);
192     f.fork();
193     f.quietlyJoin();
194     Integer r = f.getRawResult();
195     threadAssertTrue(r == 21);
196     threadAssertTrue(f.isDone());
197     return r;
198     }
199     };
200 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
201     }
202    
203    
204 jsr166 1.2 /**
205 dl 1.1 * quietlyHelpJoin of a forked task returns when task completes
206     */
207     public void testForkQuietlyHelpJoin() {
208     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
209 jsr166 1.7 public Integer compute() {
210     FibTask f = new FibTask(8);
211     f.fork();
212     f.quietlyHelpJoin();
213     Integer r = f.getRawResult();
214     threadAssertTrue(r == 21);
215     threadAssertTrue(f.isDone());
216     return r;
217     }
218     };
219 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
220     }
221    
222    
223 jsr166 1.2 /**
224 dl 1.1 * helpQuiesce returns when tasks are complete.
225     * getQueuedTaskCount returns 0 when quiescent
226     */
227     public void testForkHelpQuiesce() {
228     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
229 jsr166 1.7 public Integer compute() {
230     FibTask f = new FibTask(8);
231     f.fork();
232     f.helpQuiesce();
233     Integer r = f.getRawResult();
234     threadAssertTrue(r == 21);
235     threadAssertTrue(f.isDone());
236     threadAssertTrue(getQueuedTaskCount() == 0);
237     return r;
238     }
239     };
240 dl 1.1 assertTrue(mainPool.invoke(a) == 21);
241     }
242    
243    
244 jsr166 1.2 /**
245 dl 1.1 * invoke task throws exception when task completes abnormally
246     */
247     public void testAbnormalInvoke() {
248     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
249 jsr166 1.7 public Integer compute() {
250     try {
251     FailingFibTask f = new FailingFibTask(8);
252     f.invoke();
253     shouldThrow();
254 dl 1.1 return NoResult;
255 jsr166 1.7 } catch (FJException success) {
256 dl 1.1 }
257 jsr166 1.7 return NoResult;
258     }
259     };
260 dl 1.1 mainPool.invoke(a);
261     }
262    
263 jsr166 1.2 /**
264 jsr166 1.4 * quietlyInvoke task returns when task completes abnormally
265 dl 1.1 */
266     public void testAbnormalQuietlyInvoke() {
267     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
268 jsr166 1.7 public Integer compute() {
269     FailingFibTask f = new FailingFibTask(8);
270     f.quietlyInvoke();
271     threadAssertTrue(f.isDone());
272     return NoResult;
273     }
274     };
275 dl 1.1 mainPool.invoke(a);
276     }
277    
278 jsr166 1.2 /**
279 dl 1.1 * join of a forked task throws exception when task completes abnormally
280     */
281     public void testAbnormalForkJoin() {
282     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
283 jsr166 1.7 public Integer compute() {
284     try {
285     FailingFibTask f = new FailingFibTask(8);
286     f.fork();
287     Integer r = f.join();
288     shouldThrow();
289     return r;
290     } catch (FJException success) {
291 dl 1.1 }
292 jsr166 1.7 return NoResult;
293     }
294     };
295 dl 1.1 mainPool.invoke(a);
296     }
297    
298 jsr166 1.2 /**
299 dl 1.1 * get of a forked task throws exception when task completes abnormally
300     */
301     public void testAbnormalForkGet() {
302     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
303 jsr166 1.7 public Integer compute() {
304     try {
305     FailingFibTask f = new FailingFibTask(8);
306     f.fork();
307     Integer r = f.get();
308     shouldThrow();
309     return r;
310     } catch (ExecutionException success) {
311     } catch (Exception ex) {
312     unexpectedException(ex);
313 dl 1.1 }
314 jsr166 1.7 return NoResult;
315     }
316     };
317 dl 1.1 mainPool.invoke(a);
318     }
319    
320 jsr166 1.2 /**
321 dl 1.1 * timed get of a forked task throws exception when task completes abnormally
322     */
323     public void testAbnormalForkTimedGet() {
324     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
325 jsr166 1.7 public Integer compute() {
326     try {
327     FailingFibTask f = new FailingFibTask(8);
328     f.fork();
329     Integer r = f.get(5L, TimeUnit.SECONDS);
330     shouldThrow();
331     return r;
332     } catch (ExecutionException success) {
333     } catch (Exception ex) {
334     unexpectedException(ex);
335 dl 1.1 }
336 jsr166 1.7 return NoResult;
337     }
338     };
339 dl 1.1 mainPool.invoke(a);
340     }
341    
342 jsr166 1.2 /**
343 dl 1.1 * join of a forked task throws exception when task completes abnormally
344     */
345     public void testAbnormalForkHelpJoin() {
346     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
347 jsr166 1.7 public Integer compute() {
348     try {
349     FailingFibTask f = new FailingFibTask(8);
350     f.fork();
351     Integer r = f.helpJoin();
352     shouldThrow();
353     return r;
354     } catch (FJException success) {
355 dl 1.1 }
356 jsr166 1.7 return NoResult;
357     }
358     };
359 dl 1.1 mainPool.invoke(a);
360     }
361    
362 jsr166 1.2 /**
363 dl 1.1 * quietlyHelpJoin of a forked task returns when task completes abnormally.
364     * getException of failed task returns its exception.
365     * isCompletedAbnormally of a failed task returns true.
366     * isCancelled of a failed uncancelled task returns false
367     */
368     public void testAbnormalForkQuietlyHelpJoin() {
369     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
370 jsr166 1.7 public Integer compute() {
371     FailingFibTask f = new FailingFibTask(8);
372     f.fork();
373     f.quietlyHelpJoin();
374     threadAssertTrue(f.isDone());
375     threadAssertTrue(f.isCompletedAbnormally());
376     threadAssertFalse(f.isCancelled());
377     threadAssertTrue(f.getException() instanceof FJException);
378     return NoResult;
379     }
380     };
381 dl 1.1 mainPool.invoke(a);
382     }
383    
384 jsr166 1.2 /**
385 dl 1.1 * quietlyJoin of a forked task returns when task completes abnormally
386     */
387     public void testAbnormalForkQuietlyJoin() {
388     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
389 jsr166 1.7 public Integer compute() {
390     FailingFibTask f = new FailingFibTask(8);
391     f.fork();
392     f.quietlyJoin();
393     threadAssertTrue(f.isDone());
394     threadAssertTrue(f.isCompletedAbnormally());
395     threadAssertTrue(f.getException() instanceof FJException);
396     return NoResult;
397     }
398     };
399 dl 1.1 mainPool.invoke(a);
400     }
401    
402 jsr166 1.2 /**
403 dl 1.1 * invoke task throws exception when task cancelled
404     */
405     public void testCancelledInvoke() {
406     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
407 jsr166 1.7 public Integer compute() {
408     try {
409     FibTask f = new FibTask(8);
410     f.cancel(true);
411     Integer r = f.invoke();
412     shouldThrow();
413     return r;
414     } catch (CancellationException success) {
415 dl 1.1 }
416 jsr166 1.7 return NoResult;
417     }
418     };
419 dl 1.1 mainPool.invoke(a);
420     }
421    
422 jsr166 1.2 /**
423 dl 1.1 * join of a forked task throws exception when task cancelled
424     */
425     public void testCancelledForkJoin() {
426     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
427 jsr166 1.7 public Integer compute() {
428     try {
429     FibTask f = new FibTask(8);
430     f.cancel(true);
431     f.fork();
432     Integer r = f.join();
433     shouldThrow();
434     return r;
435     } catch (CancellationException success) {
436 dl 1.1 }
437 jsr166 1.7 return NoResult;
438     }
439     };
440 dl 1.1 mainPool.invoke(a);
441     }
442    
443 jsr166 1.2 /**
444 dl 1.1 * get of a forked task throws exception when task cancelled
445     */
446     public void testCancelledForkGet() {
447     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
448 jsr166 1.7 public Integer compute() {
449     try {
450     FibTask f = new FibTask(8);
451     f.cancel(true);
452     f.fork();
453     Integer r = f.get();
454     shouldThrow();
455     return r;
456     } catch (CancellationException success) {
457     } catch (Exception ex) {
458     unexpectedException(ex);
459 dl 1.1 }
460 jsr166 1.7 return NoResult;
461     }
462     };
463 dl 1.1 mainPool.invoke(a);
464     }
465    
466 jsr166 1.2 /**
467 dl 1.1 * timed get of a forked task throws exception when task cancelled
468     */
469     public void testCancelledForkTimedGet() {
470     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
471 jsr166 1.7 public Integer compute() {
472     try {
473     FibTask f = new FibTask(8);
474     f.cancel(true);
475     f.fork();
476     Integer r = f.get(5L, TimeUnit.SECONDS);
477     shouldThrow();
478     return r;
479     } catch (CancellationException success) {
480     } catch (Exception ex) {
481     unexpectedException(ex);
482 dl 1.1 }
483 jsr166 1.7 return NoResult;
484     }
485     };
486 dl 1.1 mainPool.invoke(a);
487     }
488    
489 jsr166 1.2 /**
490 dl 1.1 * join of a forked task throws exception when task cancelled
491     */
492     public void testCancelledForkHelpJoin() {
493     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
494 jsr166 1.7 public Integer compute() {
495     try {
496     FibTask f = new FibTask(8);
497     f.cancel(true);
498     f.fork();
499     Integer r = f.helpJoin();
500     shouldThrow();
501     return r;
502     } catch (CancellationException success) {
503 dl 1.1 }
504 jsr166 1.7 return NoResult;
505     }
506     };
507 dl 1.1 mainPool.invoke(a);
508     }
509    
510 jsr166 1.2 /**
511 dl 1.1 * quietlyHelpJoin of a forked task returns when task cancelled.
512     * getException of cancelled task returns its exception
513     * isCompletedAbnormally of a cancelled task returns true.
514     * isCancelled of a cancelled task returns true
515     */
516     public void testCancelledForkQuietlyHelpJoin() {
517     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
518 jsr166 1.7 public Integer compute() {
519     FibTask f = new FibTask(8);
520     f.cancel(true);
521     f.fork();
522     f.quietlyHelpJoin();
523     threadAssertTrue(f.isDone());
524     threadAssertTrue(f.isCompletedAbnormally());
525     threadAssertTrue(f.isCancelled());
526     threadAssertTrue(f.getException() instanceof CancellationException);
527     return NoResult;
528     }
529     };
530 dl 1.1 mainPool.invoke(a);
531     }
532    
533 jsr166 1.2 /**
534 dl 1.1 * quietlyJoin of a forked task returns when task cancelled
535     */
536     public void testCancelledForkQuietlyJoin() {
537     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
538 jsr166 1.7 public Integer compute() {
539     FibTask f = new FibTask(8);
540     f.cancel(true);
541     f.fork();
542     f.quietlyJoin();
543     threadAssertTrue(f.isDone());
544     threadAssertTrue(f.isCompletedAbnormally());
545     threadAssertTrue(f.getException() instanceof CancellationException);
546     return NoResult;
547     }
548     };
549 dl 1.1 mainPool.invoke(a);
550     }
551    
552     /**
553     * getPool of executing task returns its pool
554     */
555     public void testGetPool() {
556     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
557 jsr166 1.7 public Integer compute() {
558     threadAssertTrue(getPool() == mainPool);
559     return NoResult;
560     }
561     };
562 dl 1.1 mainPool.invoke(a);
563     }
564    
565     /**
566     * getPool of non-FJ task returns null
567     */
568     public void testGetPool2() {
569     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
570     public Integer compute() {
571     threadAssertTrue(getPool() == null);
572     return NoResult;
573     }
574     };
575     a.invoke();
576     }
577 jsr166 1.2
578 dl 1.1 /**
579     * inForkJoinPool of executing task returns true
580     */
581     public void testInForkJoinPool() {
582     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
583 jsr166 1.7 public Integer compute() {
584     threadAssertTrue(inForkJoinPool());
585     return NoResult;
586     }
587     };
588 dl 1.1 mainPool.invoke(a);
589     }
590    
591     /**
592     * inForkJoinPool of non-FJ task returns false
593     */
594     public void testInForkJoinPool2() {
595     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
596 jsr166 1.7 public Integer compute() {
597     threadAssertTrue(!inForkJoinPool());
598     return NoResult;
599     }
600     };
601 dl 1.1 a.invoke();
602     }
603    
604     /**
605     * setRawResult(null) succeeds
606     */
607     public void testSetRawResult() {
608     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
609 jsr166 1.7 public Integer compute() {
610     setRawResult(NoResult);
611     return NoResult;
612     }
613     };
614 dl 1.1 assertEquals(a.invoke(), NoResult);
615     }
616    
617 jsr166 1.2 /**
618 dl 1.1 * A reinitialized task may be re-invoked
619     */
620     public void testReinitialize() {
621     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
622 jsr166 1.7 public Integer compute() {
623     FibTask f = new FibTask(8);
624     Integer r = f.invoke();
625     threadAssertTrue(r == 21);
626     threadAssertTrue(f.isDone());
627     threadAssertFalse(f.isCancelled());
628     threadAssertFalse(f.isCompletedAbnormally());
629     f.reinitialize();
630     r = f.invoke();
631     threadAssertTrue(r == 21);
632     return NoResult;
633     }
634     };
635 dl 1.1 mainPool.invoke(a);
636     }
637    
638 jsr166 1.2 /**
639 dl 1.1 * invoke task throws exception after invoking completeExceptionally
640     */
641     public void testCompleteExceptionally() {
642     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
643 jsr166 1.7 public Integer compute() {
644     try {
645     FibTask f = new FibTask(8);
646     f.completeExceptionally(new FJException());
647     Integer r = f.invoke();
648     shouldThrow();
649     return r;
650     } catch (FJException success) {
651 dl 1.1 }
652 jsr166 1.7 return NoResult;
653     }
654     };
655 dl 1.1 mainPool.invoke(a);
656     }
657    
658 jsr166 1.2 /**
659 dl 1.1 * invoke task suppresses execution invoking complete
660     */
661     public void testComplete() {
662     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
663 jsr166 1.7 public Integer compute() {
664     FibTask f = new FibTask(8);
665     f.complete(NoResult);
666     Integer r = f.invoke();
667     threadAssertTrue(f.isDone());
668     threadAssertTrue(r == NoResult);
669     return r;
670     }
671     };
672 dl 1.1 mainPool.invoke(a);
673     }
674    
675 jsr166 1.2 /**
676 dl 1.1 * invokeAll(t1, t2) invokes all task arguments
677     */
678     public void testInvokeAll2() {
679     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
680 jsr166 1.7 public Integer compute() {
681     FibTask f = new FibTask(8);
682     FibTask g = new FibTask(9);
683     invokeAll(f, g);
684     threadAssertTrue(f.isDone());
685     threadAssertTrue(f.join() == 21);
686     threadAssertTrue(g.isDone());
687     threadAssertTrue(g.join() == 34);
688     return NoResult;
689     }
690     };
691 dl 1.1 mainPool.invoke(a);
692     }
693    
694 jsr166 1.2 /**
695 dl 1.1 * invokeAll(tasks) with 1 argument invokes task
696     */
697     public void testInvokeAll1() {
698     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
699 jsr166 1.7 public Integer compute() {
700     FibTask f = new FibTask(8);
701     invokeAll(f);
702     threadAssertTrue(f.isDone());
703     threadAssertTrue(f.join() == 21);
704     return NoResult;
705     }
706     };
707 dl 1.1 mainPool.invoke(a);
708     }
709    
710 jsr166 1.2 /**
711 dl 1.1 * invokeAll(tasks) with > 2 argument invokes tasks
712     */
713     public void testInvokeAll3() {
714     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
715 jsr166 1.7 public Integer compute() {
716     FibTask f = new FibTask(8);
717     FibTask g = new FibTask(9);
718     FibTask h = new FibTask(7);
719     invokeAll(f, g, h);
720     threadAssertTrue(f.isDone());
721     threadAssertTrue(f.join() == 21);
722     threadAssertTrue(g.isDone());
723     threadAssertTrue(g.join() == 34);
724     threadAssertTrue(h.isDone());
725     threadAssertTrue(h.join() == 13);
726     return NoResult;
727     }
728     };
729 dl 1.1 mainPool.invoke(a);
730     }
731    
732 jsr166 1.2 /**
733 dl 1.1 * invokeAll(collection) invokes all tasks in the collection
734     */
735     public void testInvokeAllCollection() {
736     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
737 jsr166 1.7 public Integer compute() {
738     FibTask f = new FibTask(8);
739     FibTask g = new FibTask(9);
740     FibTask h = new FibTask(7);
741     HashSet set = new HashSet();
742     set.add(f);
743     set.add(g);
744     set.add(h);
745     invokeAll(set);
746     threadAssertTrue(f.isDone());
747     threadAssertTrue(f.join() == 21);
748     threadAssertTrue(g.isDone());
749     threadAssertTrue(g.join() == 34);
750     threadAssertTrue(h.isDone());
751     threadAssertTrue(h.join() == 13);
752     return NoResult;
753     }
754     };
755 dl 1.1 mainPool.invoke(a);
756     }
757    
758    
759 jsr166 1.2 /**
760 dl 1.1 * invokeAll(t1, t2) throw exception if any task does
761     */
762     public void testAbnormalInvokeAll2() {
763     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
764 jsr166 1.7 public Integer compute() {
765     try {
766     FibTask f = new FibTask(8);
767     FailingFibTask g = new FailingFibTask(9);
768     invokeAll(f, g);
769     shouldThrow();
770 dl 1.1 return NoResult;
771 jsr166 1.7 } catch (FJException success) {
772 dl 1.1 }
773 jsr166 1.7 return NoResult;
774     }
775     };
776 dl 1.1 mainPool.invoke(a);
777     }
778    
779 jsr166 1.2 /**
780 dl 1.1 * invokeAll(tasks) with 1 argument throws exception if task does
781     */
782     public void testAbnormalInvokeAll1() {
783     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
784 jsr166 1.7 public Integer compute() {
785     try {
786     FailingFibTask g = new FailingFibTask(9);
787     invokeAll(g);
788     shouldThrow();
789 dl 1.1 return NoResult;
790 jsr166 1.7 } catch (FJException success) {
791 dl 1.1 }
792 jsr166 1.7 return NoResult;
793     }
794     };
795 dl 1.1 mainPool.invoke(a);
796     }
797    
798 jsr166 1.2 /**
799 dl 1.1 * invokeAll(tasks) with > 2 argument throws exception if any task does
800     */
801     public void testAbnormalInvokeAll3() {
802     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
803 jsr166 1.7 public Integer compute() {
804     try {
805     FibTask f = new FibTask(8);
806     FailingFibTask g = new FailingFibTask(9);
807     FibTask h = new FibTask(7);
808     invokeAll(f, g, h);
809     shouldThrow();
810 dl 1.1 return NoResult;
811 jsr166 1.7 } catch (FJException success) {
812 dl 1.1 }
813 jsr166 1.7 return NoResult;
814     }
815     };
816 dl 1.1 mainPool.invoke(a);
817     }
818    
819 jsr166 1.2 /**
820 jsr166 1.3 * invokeAll(collection) throws exception if any task does
821 dl 1.1 */
822     public void testAbnormalInvokeAllCollection() {
823     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
824 jsr166 1.7 public Integer compute() {
825     try {
826     FailingFibTask f = new FailingFibTask(8);
827     FibTask g = new FibTask(9);
828     FibTask h = new FibTask(7);
829     HashSet set = new HashSet();
830     set.add(f);
831     set.add(g);
832     set.add(h);
833     invokeAll(set);
834     shouldThrow();
835 dl 1.1 return NoResult;
836 jsr166 1.7 } catch (FJException success) {
837 dl 1.1 }
838 jsr166 1.7 return NoResult;
839     }
840     };
841 dl 1.1 mainPool.invoke(a);
842     }
843    
844 jsr166 1.2 /**
845 dl 1.1 * tryUnfork returns true for most recent unexecuted task,
846     * and suppresses execution
847     */
848     public void testTryUnfork() {
849     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
850 jsr166 1.7 public Integer compute() {
851     FibTask g = new FibTask(9);
852     g.fork();
853     FibTask f = new FibTask(8);
854     f.fork();
855     threadAssertTrue(f.tryUnfork());
856     helpQuiesce();
857     threadAssertFalse(f.isDone());
858     threadAssertTrue(g.isDone());
859     return NoResult;
860     }
861     };
862 dl 1.1 singletonPool.invoke(a);
863     }
864    
865 jsr166 1.2 /**
866 dl 1.1 * getSurplusQueuedTaskCount returns > 0 when
867     * there are more tasks than threads
868     */
869     public void testGetSurplusQueuedTaskCount() {
870     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
871 jsr166 1.7 public Integer compute() {
872     FibTask h = new FibTask(7);
873     h.fork();
874     FibTask g = new FibTask(9);
875     g.fork();
876     FibTask f = new FibTask(8);
877     f.fork();
878     threadAssertTrue(getSurplusQueuedTaskCount() > 0);
879     helpQuiesce();
880     return NoResult;
881     }
882     };
883 dl 1.1 singletonPool.invoke(a);
884     }
885    
886 jsr166 1.2 /**
887 dl 1.1 * peekNextLocalTask returns most recent unexecuted task.
888     */
889     public void testPeekNextLocalTask() {
890     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
891 jsr166 1.7 public Integer compute() {
892     FibTask g = new FibTask(9);
893     g.fork();
894     FibTask f = new FibTask(8);
895     f.fork();
896     threadAssertTrue(peekNextLocalTask() == f);
897     f.join();
898     threadAssertTrue(f.isDone());
899     helpQuiesce();
900     return NoResult;
901     }
902     };
903 dl 1.1 singletonPool.invoke(a);
904     }
905    
906 jsr166 1.2 /**
907 dl 1.1 * pollNextLocalTask returns most recent unexecuted task
908     * without executing it
909     */
910     public void testPollNextLocalTask() {
911     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
912 jsr166 1.7 public Integer compute() {
913     FibTask g = new FibTask(9);
914     g.fork();
915     FibTask f = new FibTask(8);
916     f.fork();
917     threadAssertTrue(pollNextLocalTask() == f);
918     helpQuiesce();
919     threadAssertFalse(f.isDone());
920     return NoResult;
921     }
922     };
923 dl 1.1 singletonPool.invoke(a);
924     }
925    
926 jsr166 1.2 /**
927 dl 1.1 * pollTask returns an unexecuted task
928     * without executing it
929     */
930     public void testPollTask() {
931     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
932 jsr166 1.7 public Integer compute() {
933     FibTask g = new FibTask(9);
934     g.fork();
935     FibTask f = new FibTask(8);
936     f.fork();
937     threadAssertTrue(pollTask() == f);
938     helpQuiesce();
939     threadAssertFalse(f.isDone());
940     threadAssertTrue(g.isDone());
941     return NoResult;
942     }
943     };
944 dl 1.1 singletonPool.invoke(a);
945     }
946    
947 jsr166 1.2 /**
948 dl 1.1 * peekNextLocalTask returns least recent unexecuted task in async mode
949     */
950     public void testPeekNextLocalTaskAsync() {
951     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
952 jsr166 1.7 public Integer compute() {
953     FibTask g = new FibTask(9);
954     g.fork();
955     FibTask f = new FibTask(8);
956     f.fork();
957     threadAssertTrue(peekNextLocalTask() == g);
958     f.join();
959     helpQuiesce();
960     threadAssertTrue(f.isDone());
961     return NoResult;
962     }
963     };
964 dl 1.1 asyncSingletonPool.invoke(a);
965     }
966    
967 jsr166 1.2 /**
968 dl 1.1 * pollNextLocalTask returns least recent unexecuted task
969     * without executing it, in async mode
970     */
971     public void testPollNextLocalTaskAsync() {
972     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
973 jsr166 1.7 public Integer compute() {
974     FibTask g = new FibTask(9);
975     g.fork();
976     FibTask f = new FibTask(8);
977     f.fork();
978     threadAssertTrue(pollNextLocalTask() == g);
979     helpQuiesce();
980     threadAssertTrue(f.isDone());
981     threadAssertFalse(g.isDone());
982     return NoResult;
983     }
984     };
985 dl 1.1 asyncSingletonPool.invoke(a);
986     }
987    
988 jsr166 1.2 /**
989 dl 1.1 * pollTask returns an unexecuted task
990     * without executing it, in async mode
991     */
992     public void testPollTaskAsync() {
993     RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
994 jsr166 1.7 public Integer compute() {
995     FibTask g = new FibTask(9);
996     g.fork();
997     FibTask f = new FibTask(8);
998     f.fork();
999     threadAssertTrue(pollTask() == g);
1000     helpQuiesce();
1001     threadAssertTrue(f.isDone());
1002     threadAssertFalse(g.isDone());
1003     return NoResult;
1004     }
1005     };
1006 dl 1.1 asyncSingletonPool.invoke(a);
1007     }
1008    
1009     }