--- jsr166/src/test/tck/RecursiveTaskTest.java	2009/11/21 02:07:27	1.8
+++ jsr166/src/test/tck/RecursiveTaskTest.java	2010/09/13 10:49:59	1.14
@@ -3,25 +3,40 @@
  * Expert Group and released to the public domain, as explained at
  * http://creativecommons.org/licenses/publicdomain
  */
+
 import junit.framework.*;
 import java.util.concurrent.*;
 import java.util.*;
 
-
 public class RecursiveTaskTest extends JSR166TestCase {
 
     public static void main(String[] args) {
-        junit.textui.TestRunner.run (suite());
+        junit.textui.TestRunner.run(suite());
     }
     public static Test suite() {
         return new TestSuite(RecursiveTaskTest.class);
     }
 
-    static final ForkJoinPool mainPool = new ForkJoinPool();
-    static final ForkJoinPool singletonPool = new ForkJoinPool(1);
-    static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
-    static {
-        asyncSingletonPool.setAsyncMode(true);
+    private static ForkJoinPool mainPool() {
+        return new ForkJoinPool();
+    }
+
+    private static ForkJoinPool singletonPool() {
+        return new ForkJoinPool(1);
+    }
+
+    private static ForkJoinPool asyncSingletonPool() {
+        return new ForkJoinPool(1,
+                                ForkJoinPool.defaultForkJoinWorkerThreadFactory,
+                                null, true);
+    }
+
+    private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
+        try {
+            return pool.invoke(a);
+        } finally {
+            joinPool(pool);
+        }
     }
 
     static final class FJException extends RuntimeException {
@@ -65,7 +80,6 @@ public class RecursiveTaskTest extends J
      * isCompletedAbnormally and isCancelled return false for normally
      * completed tasks. getRawResult of a completed non-null task
      * returns value;
-     *
      */
     public void testInvoke() {
         RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
@@ -80,7 +94,7 @@ public class RecursiveTaskTest extends J
                 return r;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -101,7 +115,7 @@ public class RecursiveTaskTest extends J
                 return r;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -118,7 +132,7 @@ public class RecursiveTaskTest extends J
                 return r;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -140,7 +154,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -162,24 +176,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
-    }
-
-    /**
-     * helpJoin of a forked task returns when task completes
-     */
-    public void testForkHelpJoin() {
-        RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
-            public Integer compute() {
-                FibTask f = new FibTask(8);
-                f.fork();
-                Integer r = f.helpJoin();
-                threadAssertTrue(r == 21);
-                threadAssertTrue(f.isDone());
-                return r;
-            }
-        };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -197,26 +194,7 @@ public class RecursiveTaskTest extends J
                 return r;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
-    }
-
-
-    /**
-     * quietlyHelpJoin of a forked task returns when task completes
-     */
-    public void testForkQuietlyHelpJoin() {
-        RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
-            public Integer compute() {
-                FibTask f = new FibTask(8);
-                f.fork();
-                f.quietlyHelpJoin();
-                Integer r = f.getRawResult();
-                threadAssertTrue(r == 21);
-                threadAssertTrue(f.isDone());
-                return r;
-            }
-        };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
 
@@ -237,7 +215,7 @@ public class RecursiveTaskTest extends J
                 return r;
             }
         };
-        assertTrue(mainPool.invoke(a) == 21);
+        assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
     }
 
 
@@ -257,7 +235,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -272,7 +250,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -292,7 +270,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -314,7 +292,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -336,49 +314,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
-    }
-
-    /**
-     * join of a forked task throws exception when task completes abnormally
-     */
-    public void testAbnormalForkHelpJoin() {
-        RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
-            public Integer compute() {
-                try {
-                    FailingFibTask f = new FailingFibTask(8);
-                    f.fork();
-                    Integer r = f.helpJoin();
-                    shouldThrow();
-                    return r;
-                } catch (FJException success) {
-                }
-                return NoResult;
-            }
-        };
-        mainPool.invoke(a);
-    }
-
-    /**
-     * quietlyHelpJoin of a forked task returns when task completes abnormally.
-     * getException of failed task returns its exception.
-     * isCompletedAbnormally of a failed task returns true.
-     * isCancelled of a failed uncancelled task returns false
-     */
-    public void testAbnormalForkQuietlyHelpJoin() {
-        RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
-            public Integer compute() {
-                FailingFibTask f = new FailingFibTask(8);
-                f.fork();
-                f.quietlyHelpJoin();
-                threadAssertTrue(f.isDone());
-                threadAssertTrue(f.isCompletedAbnormally());
-                threadAssertFalse(f.isCancelled());
-                threadAssertTrue(f.getException() instanceof FJException);
-                return NoResult;
-            }
-        };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -396,7 +332,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -416,7 +352,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -437,7 +373,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -460,7 +396,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -483,51 +419,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
-    }
-
-    /**
-     * join of a forked task throws exception when task cancelled
-     */
-    public void testCancelledForkHelpJoin() {
-        RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
-            public Integer compute() {
-                try {
-                    FibTask f = new FibTask(8);
-                    f.cancel(true);
-                    f.fork();
-                    Integer r = f.helpJoin();
-                    shouldThrow();
-                    return r;
-                } catch (CancellationException success) {
-                }
-                return NoResult;
-            }
-        };
-        mainPool.invoke(a);
-    }
-
-    /**
-     * quietlyHelpJoin of a forked task returns when task cancelled.
-     * getException of cancelled task returns its exception
-     * isCompletedAbnormally of a cancelled task returns true.
-     * isCancelled of a cancelled task returns true
-     */
-    public void testCancelledForkQuietlyHelpJoin() {
-        RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
-            public Integer compute() {
-                FibTask f = new FibTask(8);
-                f.cancel(true);
-                f.fork();
-                f.quietlyHelpJoin();
-                threadAssertTrue(f.isDone());
-                threadAssertTrue(f.isCompletedAbnormally());
-                threadAssertTrue(f.isCancelled());
-                threadAssertTrue(f.getException() instanceof CancellationException);
-                return NoResult;
-            }
-        };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -546,20 +438,21 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
      * getPool of executing task returns its pool
      */
     public void testGetPool() {
+        final ForkJoinPool mainPool = mainPool();
         RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
             public Integer compute() {
                 threadAssertTrue(getPool() == mainPool);
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool, a));
     }
 
     /**
@@ -585,7 +478,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -602,7 +495,7 @@ public class RecursiveTaskTest extends J
     }
 
     /**
-     * setRawResult(null) succeeds
+     * The value set by setRawResult is returned by invoke
      */
     public void testSetRawResult() {
         RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
@@ -611,7 +504,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        assertEquals(a.invoke(), NoResult);
+        assertSame(NoResult, a.invoke());
     }
 
     /**
@@ -632,7 +525,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -652,7 +545,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -669,7 +562,7 @@ public class RecursiveTaskTest extends J
                 return r;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -688,7 +581,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -704,7 +597,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -726,7 +619,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -752,7 +645,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
 
@@ -773,7 +666,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -792,7 +685,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -813,7 +706,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -838,7 +731,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        mainPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(mainPool(), a));
     }
 
     /**
@@ -859,7 +752,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        singletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
     }
 
     /**
@@ -880,7 +773,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        singletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
     }
 
     /**
@@ -900,7 +793,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        singletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
     }
 
     /**
@@ -920,12 +813,11 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        singletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
     }
 
     /**
-     * pollTask returns an unexecuted task
-     * without executing it
+     * pollTask returns an unexecuted task without executing it
      */
     public void testPollTask() {
         RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
@@ -941,7 +833,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        singletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
     }
 
     /**
@@ -961,7 +853,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        asyncSingletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
     }
 
     /**
@@ -982,7 +874,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        asyncSingletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
     }
 
     /**
@@ -1003,7 +895,7 @@ public class RecursiveTaskTest extends J
                 return NoResult;
             }
         };
-        asyncSingletonPool.invoke(a);
+        assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
     }
 
 }