--- jsr166/src/test/tck/RecursiveActionTest.java	2011/05/27 19:13:51	1.31
+++ jsr166/src/test/tck/RecursiveActionTest.java	2011/06/25 06:54:53	1.35
@@ -12,9 +12,11 @@ import java.util.concurrent.ForkJoinPool
 import java.util.concurrent.ForkJoinTask;
 import java.util.concurrent.ForkJoinWorkerThread;
 import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import static java.util.concurrent.TimeUnit.SECONDS;
+import java.util.Arrays;
 import java.util.HashSet;
 
 public class RecursiveActionTest extends JSR166TestCase {
@@ -267,7 +269,7 @@ public class RecursiveActionTest extends
                 assertEquals(21, f.result);
                 checkCompletedNormally(f);
 
-                f.reinitialize();
+                f = new FibAction(8);
                 f.cancel(true);
                 assertSame(f, f.fork());
                 myself.interrupt();
@@ -280,7 +282,7 @@ public class RecursiveActionTest extends
                     checkCancelled(f);
                 }
 
-                f.reinitialize();
+                f = new FibAction(8);
                 f.completeExceptionally(new FJException());
                 assertSame(f, f.fork());
                 myself.interrupt();
@@ -294,7 +296,7 @@ public class RecursiveActionTest extends
                 }
 
                 // test quietlyJoin()
-                f.reinitialize();
+                f = new FibAction(8);
                 assertSame(f, f.fork());
                 myself.interrupt();
                 assertTrue(myself.isInterrupted());
@@ -303,7 +305,7 @@ public class RecursiveActionTest extends
                 assertEquals(21, f.result);
                 checkCompletedNormally(f);
 
-                f.reinitialize();
+                f = new FibAction(8);
                 f.cancel(true);
                 assertSame(f, f.fork());
                 myself.interrupt();
@@ -312,7 +314,7 @@ public class RecursiveActionTest extends
                 Thread.interrupted();
                 checkCancelled(f);
 
-                f.reinitialize();
+                f = new FibAction(8);
                 f.completeExceptionally(new FJException());
                 assertSame(f, f.fork());
                 myself.interrupt();
@@ -789,7 +791,7 @@ public class RecursiveActionTest extends
     }
 
     /**
-     * A reinitialized task may be re-invoked
+     * A reinitialized normally completed task may be re-invoked
      */
     public void testReinitialize() {
         RecursiveAction a = new CheckedRecursiveAction() {
@@ -809,6 +811,29 @@ public class RecursiveActionTest extends
     }
 
     /**
+     * A reinitialized abnormally completed task may be re-invoked
+     */
+    public void testReinitializeAbnormal() {
+        RecursiveAction a = new CheckedRecursiveAction() {
+            public void realCompute() {
+                FailingFibAction f = new FailingFibAction(8);
+                checkNotDone(f);
+
+                for (int i = 0; i < 3; i++) {
+                    try {
+                        f.invoke();
+                        shouldThrow();
+                    } catch (FJException success) {
+                        checkCompletedAbnormally(f, success);
+                    }
+                    f.reinitialize();
+                    checkNotDone(f);
+                }
+            }};
+        testInvokeOnPool(mainPool(), a);
+    }
+
+    /**
      * invoke task throws exception after invoking completeExceptionally
      */
     public void testCompleteExceptionally() {
@@ -1172,4 +1197,48 @@ public class RecursiveActionTest extends
         testInvokeOnPool(asyncSingletonPool(), a);
     }
 
+    static class SortTask extends RecursiveAction {
+        final long[] array; final int lo, hi;
+        SortTask(long[] array, int lo, int hi) {
+            this.array = array; this.lo = lo; this.hi = hi;
+        }
+        final static int THRESHOLD = 100;
+        protected void compute() {
+            if (hi - lo < THRESHOLD)
+                sequentiallySort(array, lo, hi);
+            else {
+                int mid = (lo + hi) >>> 1;
+                invokeAll(new SortTask(array, lo, mid),
+                          new SortTask(array, mid, hi));
+                merge(array, lo, mid, hi);
+            }
+        }
+        static void sequentiallySort(long[] array, int lo, int hi) {
+            Arrays.sort(array, lo, hi);
+        }
+        static void merge(long[] array, int lo, int mid, int hi) {
+            int n = hi - lo;
+            long[] buf = new long[n];
+            int a = lo, b = mid;
+            for (int i = 0; i < n; i++)
+                buf[i] = (b == hi || (a < mid && array[a] < array[b])) ?
+                    array[a++] : array[b++];
+            System.arraycopy(buf, 0, array, lo, n);
+        }
+    }
+
+    /**
+     * SortTask demo works as advertised
+     */
+    public void testSortTaskDemo() {
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        long[] array = new long[1007];
+        for (int i = 0; i < array.length; i++)
+            array[i] = rnd.nextLong();
+        long[] arrayClone = array.clone();
+        testInvokeOnPool(mainPool(),
+                         new SortTask(array, 0, array.length));
+        Arrays.sort(arrayClone);
+        assertTrue(Arrays.equals(array, arrayClone));
+    }
 }