--- jsr166/src/test/tck/ForkJoinTaskTest.java	2010/08/11 19:50:02	1.8
+++ jsr166/src/test/tck/ForkJoinTaskTest.java	2010/09/13 07:22:29	1.12
@@ -28,8 +28,9 @@ import java.util.*;
 public class ForkJoinTaskTest 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(ForkJoinTaskTest.class);
     }
@@ -44,7 +45,7 @@ public class ForkJoinTaskTest extends JS
 
     static final ForkJoinPool mainPool = new ForkJoinPool();
     static final ForkJoinPool singletonPool = new ForkJoinPool(1);
-    static final ForkJoinPool asyncSingletonPool = 
+    static final ForkJoinPool asyncSingletonPool =
         new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                          null, true);
     static final class FJException extends RuntimeException {
@@ -224,20 +225,18 @@ public class ForkJoinTaskTest extends JS
      * invoke returns when task completes normally.
      * isCompletedAbnormally and isCancelled return false for normally
      * completed tasks. getRawResult of a RecursiveAction returns null;
-     *
      */
     public void testInvoke() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    f.invoke();
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(f.isDone());
-                    threadAssertFalse(f.isCancelled());
-                    threadAssertFalse(f.isCompletedAbnormally());
-                    threadAssertTrue(f.getRawResult() == null);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                f.invoke();
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(f.isDone());
+                threadAssertFalse(f.isCancelled());
+                threadAssertFalse(f.isCompletedAbnormally());
+                threadAssertTrue(f.getRawResult() == null);
+            }};
         mainPool.invoke(a);
     }
 
@@ -248,16 +247,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testQuietlyInvoke() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    f.quietlyInvoke();
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(f.isDone());
-                    threadAssertFalse(f.isCancelled());
-                    threadAssertFalse(f.isCompletedAbnormally());
-                    threadAssertTrue(f.getRawResult() == null);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                f.quietlyInvoke();
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(f.isDone());
+                threadAssertFalse(f.isCancelled());
+                threadAssertFalse(f.isCompletedAbnormally());
+                threadAssertTrue(f.getRawResult() == null);
+            }};
         mainPool.invoke(a);
     }
 
@@ -266,15 +264,14 @@ public class ForkJoinTaskTest extends JS
      */
     public void testForkJoin() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    f.join();
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.getRawResult() == null);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                f.join();
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.getRawResult() == null);
+            }};
         mainPool.invoke(a);
     }
 
@@ -283,18 +280,17 @@ public class ForkJoinTaskTest extends JS
      */
     public void testForkGet() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.fork();
-                        f.get();
-                        threadAssertTrue(f.number == 21);
-                        threadAssertTrue(f.isDone());
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.fork();
+                    f.get();
+                    threadAssertTrue(f.number == 21);
+                    threadAssertTrue(f.isDone());
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -303,18 +299,17 @@ public class ForkJoinTaskTest extends JS
      */
     public void testForkTimedGet() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.fork();
-                        f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-                        threadAssertTrue(f.number == 21);
-                        threadAssertTrue(f.isDone());
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.fork();
+                    f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+                    threadAssertTrue(f.number == 21);
+                    threadAssertTrue(f.isDone());
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -323,18 +318,17 @@ public class ForkJoinTaskTest extends JS
      */
     public void testForkTimedGetNPE() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.fork();
-                        f.get(5L, null);
-                        shouldThrow();
-                    } catch (NullPointerException success) {
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.fork();
+                    f.get(5L, null);
+                    shouldThrow();
+                } catch (NullPointerException success) {
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -343,14 +337,13 @@ public class ForkJoinTaskTest extends JS
      */
     public void testForkQuietlyJoin() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    f.quietlyJoin();
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(f.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                f.quietlyJoin();
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(f.isDone());
+            }};
         mainPool.invoke(a);
     }
 
@@ -361,15 +354,14 @@ public class ForkJoinTaskTest extends JS
      */
     public void testForkHelpQuiesce() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    f.helpQuiesce();
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(getQueuedTaskCount() == 0);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                f.helpQuiesce();
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(getQueuedTaskCount() == 0);
+            }};
         mainPool.invoke(a);
     }
 
@@ -379,15 +371,14 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalInvoke() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        FailingAsyncFib f = new FailingAsyncFib(8);
-                        f.invoke();
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    FailingAsyncFib f = new FailingAsyncFib(8);
+                    f.invoke();
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -396,12 +387,11 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalQuietlyInvoke() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    FailingAsyncFib f = new FailingAsyncFib(8);
-                    f.quietlyInvoke();
-                    threadAssertTrue(f.isDone());
-                }
-            };
+            public void compute() {
+                FailingAsyncFib f = new FailingAsyncFib(8);
+                f.quietlyInvoke();
+                threadAssertTrue(f.isDone());
+            }};
         mainPool.invoke(a);
     }
 
@@ -410,16 +400,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalForkJoin() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        FailingAsyncFib f = new FailingAsyncFib(8);
-                        f.fork();
-                        f.join();
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    FailingAsyncFib f = new FailingAsyncFib(8);
+                    f.fork();
+                    f.join();
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -428,18 +417,17 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalForkGet() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        FailingAsyncFib f = new FailingAsyncFib(8);
-                        f.fork();
-                        f.get();
-                        shouldThrow();
-                    } catch (ExecutionException success) {
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    FailingAsyncFib f = new FailingAsyncFib(8);
+                    f.fork();
+                    f.get();
+                    shouldThrow();
+                } catch (ExecutionException success) {
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -448,18 +436,17 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalForkTimedGet() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        FailingAsyncFib f = new FailingAsyncFib(8);
-                        f.fork();
-                        f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-                        shouldThrow();
-                    } catch (ExecutionException success) {
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    FailingAsyncFib f = new FailingAsyncFib(8);
+                    f.fork();
+                    f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+                    shouldThrow();
+                } catch (ExecutionException success) {
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -468,15 +455,14 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalForkQuietlyJoin() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    FailingAsyncFib f = new FailingAsyncFib(8);
-                    f.fork();
-                    f.quietlyJoin();
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.isCompletedAbnormally());
-                    threadAssertTrue(f.getException() instanceof FJException);
-                }
-            };
+            public void compute() {
+                FailingAsyncFib f = new FailingAsyncFib(8);
+                f.fork();
+                f.quietlyJoin();
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.isCompletedAbnormally());
+                threadAssertTrue(f.getException() instanceof FJException);
+            }};
         mainPool.invoke(a);
     }
 
@@ -485,16 +471,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testCancelledInvoke() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.cancel(true);
-                        f.invoke();
-                        shouldThrow();
-                    } catch (CancellationException success) {
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.cancel(true);
+                    f.invoke();
+                    shouldThrow();
+                } catch (CancellationException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -503,17 +488,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testCancelledForkJoin() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.cancel(true);
-                        f.fork();
-                        f.join();
-                        shouldThrow();
-                    } catch (CancellationException success) {
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.cancel(true);
+                    f.fork();
+                    f.join();
+                    shouldThrow();
+                } catch (CancellationException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -522,19 +506,18 @@ public class ForkJoinTaskTest extends JS
      */
     public void testCancelledForkGet() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.cancel(true);
-                        f.fork();
-                        f.get();
-                        shouldThrow();
-                    } catch (CancellationException success) {
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.cancel(true);
+                    f.fork();
+                    f.get();
+                    shouldThrow();
+                } catch (CancellationException success) {
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -543,19 +526,18 @@ public class ForkJoinTaskTest extends JS
      */
     public void testCancelledForkTimedGet() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.cancel(true);
-                        f.fork();
-                        f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-                        shouldThrow();
-                    } catch (CancellationException success) {
-                    } catch (Exception ex) {
-                        unexpectedException(ex);
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.cancel(true);
+                    f.fork();
+                    f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+                    shouldThrow();
+                } catch (CancellationException success) {
+                } catch (Exception ex) {
+                    unexpectedException(ex);
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -564,16 +546,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testCancelledForkQuietlyJoin() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    f.cancel(true);
-                    f.fork();
-                    f.quietlyJoin();
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.isCompletedAbnormally());
-                    threadAssertTrue(f.getException() instanceof CancellationException);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                f.cancel(true);
+                f.fork();
+                f.quietlyJoin();
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.isCompletedAbnormally());
+                threadAssertTrue(f.getException() instanceof CancellationException);
+            }};
         mainPool.invoke(a);
     }
 
@@ -582,10 +563,9 @@ public class ForkJoinTaskTest extends JS
      */
     public void testGetPool() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    threadAssertTrue(getPool() == mainPool);
-                }
-            };
+            public void compute() {
+                threadAssertTrue(getPool() == mainPool);
+            }};
         mainPool.invoke(a);
     }
 
@@ -594,10 +574,9 @@ public class ForkJoinTaskTest extends JS
      */
     public void testGetPool2() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    threadAssertTrue(getPool() == null);
-                }
-            };
+            public void compute() {
+                threadAssertTrue(getPool() == null);
+            }};
         a.invoke();
     }
 
@@ -606,10 +585,9 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInForkJoinPool() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    threadAssertTrue(inForkJoinPool());
-                }
-            };
+            public void compute() {
+                threadAssertTrue(inForkJoinPool());
+            }};
         mainPool.invoke(a);
     }
 
@@ -618,10 +596,9 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInForkJoinPool2() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    threadAssertTrue(!inForkJoinPool());
-                }
-            };
+            public void compute() {
+                threadAssertTrue(!inForkJoinPool());
+            }};
         a.invoke();
     }
 
@@ -630,10 +607,9 @@ public class ForkJoinTaskTest extends JS
      */
     public void testSetRawResult() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    setRawResult(null);
-                }
-            };
+            public void compute() {
+                setRawResult(null);
+            }};
         a.invoke();
     }
 
@@ -642,16 +618,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testCompleteExceptionally() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        f.completeExceptionally(new FJException());
-                        f.invoke();
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    f.completeExceptionally(new FJException());
+                    f.invoke();
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -660,16 +635,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInvokeAll2() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    AsyncFib g = new AsyncFib(9);
-                    invokeAll(f, g);
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(g.isDone());
-                    threadAssertTrue(g.number == 34);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                AsyncFib g = new AsyncFib(9);
+                invokeAll(f, g);
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(g.isDone());
+                threadAssertTrue(g.number == 34);
+            }};
         mainPool.invoke(a);
     }
 
@@ -678,13 +652,12 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInvokeAll1() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    invokeAll(f);
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.number == 21);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                invokeAll(f);
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.number == 21);
+            }};
         mainPool.invoke(a);
     }
 
@@ -693,19 +666,18 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInvokeAll3() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    AsyncFib g = new AsyncFib(9);
-                    AsyncFib h = new AsyncFib(7);
-                    invokeAll(f, g, h);
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(g.isDone());
-                    threadAssertTrue(g.number == 34);
-                    threadAssertTrue(h.isDone());
-                    threadAssertTrue(h.number == 13);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                AsyncFib g = new AsyncFib(9);
+                AsyncFib h = new AsyncFib(7);
+                invokeAll(f, g, h);
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(g.isDone());
+                threadAssertTrue(g.number == 34);
+                threadAssertTrue(h.isDone());
+                threadAssertTrue(h.number == 13);
+            }};
         mainPool.invoke(a);
     }
 
@@ -714,23 +686,22 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInvokeAllCollection() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib f = new AsyncFib(8);
-                    AsyncFib g = new AsyncFib(9);
-                    AsyncFib h = new AsyncFib(7);
-                    HashSet set = new HashSet();
-                    set.add(f);
-                    set.add(g);
-                    set.add(h);
-                    invokeAll(set);
-                    threadAssertTrue(f.isDone());
-                    threadAssertTrue(f.number == 21);
-                    threadAssertTrue(g.isDone());
-                    threadAssertTrue(g.number == 34);
-                    threadAssertTrue(h.isDone());
-                    threadAssertTrue(h.number == 13);
-                }
-            };
+            public void compute() {
+                AsyncFib f = new AsyncFib(8);
+                AsyncFib g = new AsyncFib(9);
+                AsyncFib h = new AsyncFib(7);
+                HashSet set = new HashSet();
+                set.add(f);
+                set.add(g);
+                set.add(h);
+                invokeAll(set);
+                threadAssertTrue(f.isDone());
+                threadAssertTrue(f.number == 21);
+                threadAssertTrue(g.isDone());
+                threadAssertTrue(g.number == 34);
+                threadAssertTrue(h.isDone());
+                threadAssertTrue(h.number == 13);
+            }};
         mainPool.invoke(a);
     }
 
@@ -740,17 +711,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testInvokeAllNPE() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        AsyncFib g = new AsyncFib(9);
-                        AsyncFib h = null;
-                        invokeAll(f, g, h);
-                        shouldThrow();
-                    } catch (NullPointerException success) {
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    AsyncFib g = new AsyncFib(9);
+                    AsyncFib h = null;
+                    invokeAll(f, g, h);
+                    shouldThrow();
+                } catch (NullPointerException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -759,16 +729,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalInvokeAll2() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        FailingAsyncFib g = new FailingAsyncFib(9);
-                        invokeAll(f, g);
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    FailingAsyncFib g = new FailingAsyncFib(9);
+                    invokeAll(f, g);
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -777,15 +746,14 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalInvokeAll1() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        FailingAsyncFib g = new FailingAsyncFib(9);
-                        invokeAll(g);
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    FailingAsyncFib g = new FailingAsyncFib(9);
+                    invokeAll(g);
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -794,17 +762,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalInvokeAll3() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        AsyncFib f = new AsyncFib(8);
-                        FailingAsyncFib g = new FailingAsyncFib(9);
-                        AsyncFib h = new AsyncFib(7);
-                        invokeAll(f, g, h);
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    AsyncFib f = new AsyncFib(8);
+                    FailingAsyncFib g = new FailingAsyncFib(9);
+                    AsyncFib h = new AsyncFib(7);
+                    invokeAll(f, g, h);
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -813,21 +780,20 @@ public class ForkJoinTaskTest extends JS
      */
     public void testAbnormalInvokeAllCollection() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    try {
-                        FailingAsyncFib f = new FailingAsyncFib(8);
-                        AsyncFib g = new AsyncFib(9);
-                        AsyncFib h = new AsyncFib(7);
-                        HashSet set = new HashSet();
-                        set.add(f);
-                        set.add(g);
-                        set.add(h);
-                        invokeAll(set);
-                        shouldThrow();
-                    } catch (FJException success) {
-                    }
+            public void compute() {
+                try {
+                    FailingAsyncFib f = new FailingAsyncFib(8);
+                    AsyncFib g = new AsyncFib(9);
+                    AsyncFib h = new AsyncFib(7);
+                    HashSet set = new HashSet();
+                    set.add(f);
+                    set.add(g);
+                    set.add(h);
+                    invokeAll(set);
+                    shouldThrow();
+                } catch (FJException success) {
                 }
-            };
+            }};
         mainPool.invoke(a);
     }
 
@@ -837,17 +803,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testTryUnfork() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(f.tryUnfork());
-                    helpQuiesce();
-                    threadAssertFalse(f.isDone());
-                    threadAssertTrue(g.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(f.tryUnfork());
+                helpQuiesce();
+                threadAssertFalse(f.isDone());
+                threadAssertTrue(g.isDone());
+            }};
         singletonPool.invoke(a);
     }
 
@@ -857,17 +822,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testGetSurplusQueuedTaskCount() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib h = new AsyncFib(7);
-                    h.fork();
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(getSurplusQueuedTaskCount() > 0);
-                    helpQuiesce();
-                }
-            };
+            public void compute() {
+                AsyncFib h = new AsyncFib(7);
+                h.fork();
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(getSurplusQueuedTaskCount() > 0);
+                helpQuiesce();
+            }};
         singletonPool.invoke(a);
     }
 
@@ -876,17 +840,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testPeekNextLocalTask() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(peekNextLocalTask() == f);
-                    f.join();
-                    threadAssertTrue(f.isDone());
-                    helpQuiesce();
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(peekNextLocalTask() == f);
+                f.join();
+                threadAssertTrue(f.isDone());
+                helpQuiesce();
+            }};
         singletonPool.invoke(a);
     }
 
@@ -896,16 +859,15 @@ public class ForkJoinTaskTest extends JS
      */
     public void testPollNextLocalTask() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(pollNextLocalTask() == f);
-                    helpQuiesce();
-                    threadAssertFalse(f.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(pollNextLocalTask() == f);
+                helpQuiesce();
+                threadAssertFalse(f.isDone());
+            }};
         singletonPool.invoke(a);
     }
 
@@ -915,17 +877,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testPollTask() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(pollTask() == f);
-                    helpQuiesce();
-                    threadAssertFalse(f.isDone());
-                    threadAssertTrue(g.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(pollTask() == f);
+                helpQuiesce();
+                threadAssertFalse(f.isDone());
+                threadAssertTrue(g.isDone());
+            }};
         singletonPool.invoke(a);
     }
 
@@ -934,17 +895,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testPeekNextLocalTaskAsync() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(peekNextLocalTask() == g);
-                    f.join();
-                    helpQuiesce();
-                    threadAssertTrue(f.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(peekNextLocalTask() == g);
+                f.join();
+                helpQuiesce();
+                threadAssertTrue(f.isDone());
+            }};
         asyncSingletonPool.invoke(a);
     }
 
@@ -954,17 +914,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testPollNextLocalTaskAsync() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(pollNextLocalTask() == g);
-                    helpQuiesce();
-                    threadAssertTrue(f.isDone());
-                    threadAssertFalse(g.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(pollNextLocalTask() == g);
+                helpQuiesce();
+                threadAssertTrue(f.isDone());
+                threadAssertFalse(g.isDone());
+            }};
         asyncSingletonPool.invoke(a);
     }
 
@@ -974,17 +933,16 @@ public class ForkJoinTaskTest extends JS
      */
     public void testPollTaskAsync() {
         RecursiveAction a = new RecursiveAction() {
-                public void compute() {
-                    AsyncFib g = new AsyncFib(9);
-                    g.fork();
-                    AsyncFib f = new AsyncFib(8);
-                    f.fork();
-                    threadAssertTrue(pollTask() == g);
-                    helpQuiesce();
-                    threadAssertTrue(f.isDone());
-                    threadAssertFalse(g.isDone());
-                }
-            };
+            public void compute() {
+                AsyncFib g = new AsyncFib(9);
+                g.fork();
+                AsyncFib f = new AsyncFib(8);
+                f.fork();
+                threadAssertTrue(pollTask() == g);
+                helpQuiesce();
+                threadAssertTrue(f.isDone());
+                threadAssertFalse(g.isDone());
+            }};
         asyncSingletonPool.invoke(a);
     }
 }