--- jsr166/src/test/tck/JSR166TestCase.java	2008/04/13 14:16:25	1.31
+++ jsr166/src/test/tck/JSR166TestCase.java	2009/08/03 22:08:45	1.36
@@ -9,6 +9,7 @@
 import junit.framework.*;
 import java.util.*;
 import java.util.concurrent.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import java.io.*;
 import java.security.*;
 
@@ -108,6 +109,13 @@ public class JSR166TestCase extends Test
     public static Test suite ( ) {
         TestSuite suite = new TestSuite("JSR166 Unit Tests");
 
+        suite.addTest(new TestSuite(ForkJoinPoolTest.class));
+        suite.addTest(new TestSuite(ForkJoinTaskTest.class));
+        suite.addTest(new TestSuite(RecursiveActionTest.class));
+        suite.addTest(new TestSuite(RecursiveTaskTest.class));
+        suite.addTest(new TestSuite(LinkedTransferQueueTest.class));
+        suite.addTest(new TestSuite(PhaserTest.class));
+        suite.addTest(new TestSuite(ThreadLocalRandomTest.class));
         suite.addTest(new TestSuite(AbstractExecutorServiceTest.class));
         suite.addTest(new TestSuite(AbstractQueueTest.class));
         suite.addTest(new TestSuite(AbstractQueuedSynchronizerTest.class));
@@ -279,15 +287,15 @@ public class JSR166TestCase extends Test
 
     /**
      * threadFail with message "should throw exception"
-     */ 
+     */
     public void threadShouldThrow() {
-       try {
-           threadFailed = true;
-           fail("should throw exception");
-       } catch (AssertionFailedError e) {
-           e.printStackTrace();
-           throw e;
-       }
+        try {
+            threadFailed = true;
+            fail("should throw exception");
+        } catch (AssertionFailedError e) {
+            e.printStackTrace();
+            throw e;
+        }
     }
 
     /**
@@ -313,10 +321,10 @@ public class JSR166TestCase extends Test
     public void joinPool(ExecutorService exec) {
         try {
             exec.shutdown();
-            assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
-        } catch(SecurityException ok) {
+            assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
+        } catch (SecurityException ok) {
             // Allowed in case test doesn't have privs
-        } catch(InterruptedException ie) {
+        } catch (InterruptedException ie) {
             fail("Unexpected exception");
         }
     }
@@ -336,6 +344,14 @@ public class JSR166TestCase extends Test
         fail("Unexpected exception");
     }
 
+    /**
+     * fail with message "Unexpected exception", with argument
+     */
+    public void unexpectedException(Throwable ex) {
+        ex.printStackTrace();
+        fail("Unexpected exception: " + ex);
+    }
+
 
     /**
      * The number of elements to place in collections, arrays, etc.
@@ -387,6 +403,45 @@ public class JSR166TestCase extends Test
 
     // Some convenient Runnable classes
 
+    abstract class CheckedRunnable implements Runnable {
+        abstract void realRun() throws Throwable;
+
+        public final void run() {
+            try {
+                realRun();
+            } catch (Throwable t) {
+                threadUnexpectedException(t);
+            }
+        }
+    }
+
+    abstract class CheckedInterruptedRunnable implements Runnable {
+        abstract void realRun() throws Throwable;
+
+        public final void run() {
+            try {
+                realRun();
+                threadShouldThrow();
+            } catch (InterruptedException success) {
+            } catch (Throwable t) {
+                threadUnexpectedException(t);
+            }
+        }
+    }
+
+    abstract class CheckedCallable<T> implements Callable<T> {
+        abstract T realCall() throws Throwable;
+
+        public final T call() {
+            try {
+                return realCall();
+            } catch (Throwable t) {
+                threadUnexpectedException(t);
+                return null;
+            }
+        }
+    }
+
     static class NoOpRunnable implements Runnable {
         public void run() {}
     }
@@ -409,111 +464,75 @@ public class JSR166TestCase extends Test
         public Integer call() { return one; }
     }
 
-    class ShortRunnable implements Runnable {
-        public void run() {
-            try {
-                Thread.sleep(SHORT_DELAY_MS);
-            }
-            catch(Exception e) {
-                threadUnexpectedException(e);
-            }
+    class ShortRunnable extends CheckedRunnable {
+        void realRun() throws Throwable {
+            Thread.sleep(SHORT_DELAY_MS);
         }
     }
 
-    class ShortInterruptedRunnable implements Runnable {
-        public void run() {
-            try {
-                Thread.sleep(SHORT_DELAY_MS);
-                threadShouldThrow();
-            }
-            catch(InterruptedException success) {
-            }
+    class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
+        void realRun() throws InterruptedException {
+            Thread.sleep(SHORT_DELAY_MS);
         }
     }
 
-    class SmallRunnable implements Runnable {
-        public void run() {
-            try {
-                Thread.sleep(SMALL_DELAY_MS);
-            }
-            catch(Exception e) {
-                threadUnexpectedException(e);
-            }
+    class SmallRunnable extends CheckedRunnable {
+        void realRun() throws Throwable {
+            Thread.sleep(SMALL_DELAY_MS);
         }
     }
 
-    class SmallPossiblyInterruptedRunnable implements Runnable {
-        public void run() {
+    class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
+        void realRun() {
             try {
                 Thread.sleep(SMALL_DELAY_MS);
             }
-            catch(Exception e) {
+            catch (InterruptedException ok) {
             }
         }
     }
 
-    class SmallCallable implements Callable {
-        public Object call() {
-            try {
-                Thread.sleep(SMALL_DELAY_MS);
-            }
-            catch(Exception e) {
-                threadUnexpectedException(e);
-            }
+    class SmallCallable extends CheckedCallable {
+        Object realCall() throws Throwable {
+            Thread.sleep(SMALL_DELAY_MS);
             return Boolean.TRUE;
         }
     }
 
-    class SmallInterruptedRunnable implements Runnable {
-        public void run() {
-            try {
-                Thread.sleep(SMALL_DELAY_MS);
-                threadShouldThrow();
-            }
-            catch(InterruptedException success) {
-            }
+    class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
+        void realRun() throws InterruptedException {
+            Thread.sleep(SMALL_DELAY_MS);
         }
     }
 
-
-    class MediumRunnable implements Runnable {
-        public void run() {
-            try {
-                Thread.sleep(MEDIUM_DELAY_MS);
-            }
-            catch(Exception e) {
-                threadUnexpectedException(e);
-            }
+    class MediumRunnable extends CheckedRunnable {
+        void realRun() throws Throwable {
+            Thread.sleep(MEDIUM_DELAY_MS);
         }
     }
 
-    class MediumInterruptedRunnable implements Runnable {
-        public void run() {
-            try {
-                Thread.sleep(MEDIUM_DELAY_MS);
-                threadShouldThrow();
-            }
-            catch(InterruptedException success) {
-            }
+    class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
+        void realRun() throws InterruptedException {
+            Thread.sleep(MEDIUM_DELAY_MS);
         }
     }
 
-    class MediumPossiblyInterruptedRunnable implements Runnable {
-        public void run() {
+    class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
+        void realRun() {
             try {
                 Thread.sleep(MEDIUM_DELAY_MS);
             }
-            catch(InterruptedException success) {
+            catch (InterruptedException ok) {
             }
         }
     }
 
-    class LongPossiblyInterruptedRunnable implements Runnable {
-        public void run() {
+    class LongPossiblyInterruptedRunnable extends CheckedRunnable {
+        void realRun() {
             try {
                 Thread.sleep(LONG_DELAY_MS);
             }
-            catch(InterruptedException success) {
+            catch (InterruptedException ok) {
             }
         }
     }
@@ -521,8 +540,8 @@ public class JSR166TestCase extends Test
     /**
      * For use as ThreadFactory in constructors
      */
-    static class SimpleThreadFactory implements ThreadFactory{
-        public Thread newThread(Runnable r){
+    static class SimpleThreadFactory implements ThreadFactory {
+        public Thread newThread(Runnable r) {
             return new Thread(r);
         }
     }
@@ -533,7 +552,7 @@ public class JSR166TestCase extends Test
             try {
                 Thread.sleep(SMALL_DELAY_MS);
                 done = true;
-            } catch(Exception e){
+            } catch (Exception e) {
             }
         }
     }
@@ -544,7 +563,7 @@ public class JSR166TestCase extends Test
             try {
                 Thread.sleep(MEDIUM_DELAY_MS);
                 done = true;
-            } catch(Exception e){
+            } catch (Exception e) {
             }
         }
     }
@@ -555,7 +574,7 @@ public class JSR166TestCase extends Test
             try {
                 Thread.sleep(LONG_DELAY_MS);
                 done = true;
-            } catch(Exception e){
+            } catch (Exception e) {
             }
         }
     }
@@ -573,7 +592,7 @@ public class JSR166TestCase extends Test
             try {
                 Thread.sleep(SMALL_DELAY_MS);
                 done = true;
-            } catch(Exception e){
+            } catch (Exception e) {
             }
             return Boolean.TRUE;
         }
@@ -583,9 +602,9 @@ public class JSR166TestCase extends Test
     /**
      * For use as RejectedExecutionHandler in constructors
      */
-    static class NoOpREHandler implements RejectedExecutionHandler{
-        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){}
+    static class NoOpREHandler implements RejectedExecutionHandler {
+        public void rejectedExecution(Runnable r,
+                                      ThreadPoolExecutor executor) {}
     }
 
-
 }