--- jsr166/src/test/tck/ExecutorsTest.java	2003/09/07 20:39:11	1.2
+++ jsr166/src/test/tck/ExecutorsTest.java	2003/09/20 18:20:07	1.4
@@ -11,130 +11,161 @@ import java.util.*;
 import java.util.concurrent.*;
 import java.math.BigInteger;
 
-public class ExecutorsTest extends TestCase{
-    
+public class ExecutorsTest extends JSR166TestCase{
+   
     public static void main(String[] args) {
 	junit.textui.TestRunner.run (suite());	
     }
-    
-
     public static Test suite() {
 	return new TestSuite(ExecutorsTest.class);
     }
 
-    private static long SHORT_DELAY_MS = 100; 
-    private static long MEDIUM_DELAY_MS = 1000;
-    private static long LONG_DELAY_MS = 10000; 
-
-    class SleepRun implements Runnable {
-        public void run() {
-            try{
-                Thread.sleep(MEDIUM_DELAY_MS);
-            } catch(InterruptedException e){
-                fail("unexpected exception");
-            }
+    private static final String TEST_STRING = "a test string";
+
+    private static class MyTask implements Runnable {
+        public void run() { completed = true; }
+        public boolean isCompleted() { return completed; }
+        public void reset() { completed = false; }
+        private boolean completed = false;
+    }
+
+    private static class StringTask implements Callable<String> {
+        public String call() { return TEST_STRING; }
+    }
+
+    static class DirectExecutor implements Executor {
+        public void execute(Runnable r) {
+            r.run();
         }
     }
-    
 
-    class SleepCall implements Callable {
-        public Object call(){
-            try{
-                Thread.sleep(MEDIUM_DELAY_MS);
-            }catch(InterruptedException e){
-                fail("unexpected exception");
+    static class TimedCallable<T> implements Callable<T> {
+        private final Executor exec;
+        private final Callable<T> func;
+        private final long msecs;
+        
+        TimedCallable(Executor exec, Callable<T> func, long msecs) {
+            this.exec = exec;
+            this.func = func;
+            this.msecs = msecs;
+        }
+        
+        public T call() throws Exception {
+            Future<T> ftask = Executors.execute(exec, func);
+            try {
+                return ftask.get(msecs, TimeUnit.MILLISECONDS);
+            } finally {
+                ftask.cancel(true);
             }
-            return Boolean.TRUE;
         }
     }
 
 
+    private static class Fib implements Callable<BigInteger> {
+        private final BigInteger n;
+        Fib(long n) {
+            if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
+            this.n = BigInteger.valueOf(n);
+        }
+        public BigInteger call() {
+            BigInteger f1 = BigInteger.ONE;
+            BigInteger f2 = f1;
+            for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
+                BigInteger t = f1.add(f2);
+                f1 = f2;
+                f2 = t;
+            }
+            return f1;
+        }
+    };
+
+
 
     /**
-     *  Test to verify execute(Executor, Runnable) will throw
+     *   execute(Executor, Runnable) will throw
      *  RejectedExecutionException Attempting to execute a runnable on
      *  a full ThreadPool will cause such an exception here, up to 5
      *  runnables are attempted on a pool capable on handling one
      *  until it throws an exception
      */
-    public void testExecute1(){
-        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
-        try{
+    public void testExecute1() {
+        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
+        try {
             
             for(int i = 0; i < 5; ++i){
-                Executors.execute(p, new SleepRun(), Boolean.TRUE);
+                Executors.execute(p, new MediumRunnable(), Boolean.TRUE);
             }
-            fail("should throw");
+            shouldThrow();
         } catch(RejectedExecutionException success){}
-        p.shutdownNow();
+        joinPool(p);
     }
 
     /**
-     *  Test to verify execute(Executor, Callable) will throw
+     *   execute(Executor, Callable) will throw
      *  RejectedExecutionException Attempting to execute a callable on
      *  a full ThreadPool will cause such an exception here, up to 5
      *  runnables are attempted on a pool capable on handling one
      *  until it throws an exception
      */
-    public void testExecute2(){
-         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
-        try{
+    public void testExecute2() {
+         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
+        try {
             for(int i = 0; i < 5; ++i) {
-                Executors.execute(p, new SleepCall());
+                Executors.execute(p, new SmallCallable());
             }
-            fail("should throw");
-        }catch(RejectedExecutionException e){}
-        p.shutdownNow();
+            shouldThrow();
+        } catch(RejectedExecutionException e){}
+        joinPool(p);
     }
 
 
     /**
-     *  Test to verify invoke(Executor, Runnable) throws InterruptedException
+     *   invoke(Executor, Runnable) throws InterruptedException
      *  A single use of invoke starts that will wait long enough
      *  for the invoking thread to be interrupted
      */
-    public void testInvoke2(){
-        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
+    public void testInvoke2() {
+        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
         Thread t = new Thread(new Runnable() {
-                public void run(){
-                    try{
-                        Executors.invoke(p,new Runnable(){
-                                public void run(){
-                                    try{
+                public void run() {
+                    try {
+                        Executors.invoke(p,new Runnable() {
+                                public void run() {
+                                    try {
                                         Thread.sleep(MEDIUM_DELAY_MS);
-                                        fail("should throw");
-                                    }catch(InterruptedException e){
+                                        shouldThrow();
+                                    } catch(InterruptedException e){
                                     }
                                 }
                             });
                     } catch(InterruptedException success){
                     } catch(Exception e) {
-                        fail("unexpected exception");
+                        unexpectedException();
                     }
                     
                 }
             }); 
-        try{
+        try {
             t.start();
             Thread.sleep(SHORT_DELAY_MS);
             t.interrupt();
-        }catch(Exception e){
-            fail("unexpected exception");
+        } catch(Exception e){
+            unexpectedException();
         }
-        p.shutdownNow();
+        joinPool(p);
     }
 
     /**
-     *  Test to verify invoke(Executor, Runnable) will throw
+     *   invoke(Executor, Runnable) will throw
      *  ExecutionException An ExecutionException occurs when the
      *  underlying Runnable throws an exception, here the
      *  DivideByZeroException will cause an ExecutionException
      */
-    public void testInvoke3(){
-        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
-        try{
-            Runnable r = new Runnable(){
-                    public void run(){
+    public void testInvoke3() {
+        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
+        try {
+            Runnable r = new Runnable() {
+                    public void run() {
                         int i = 5/0;
                     }
                 };
@@ -143,30 +174,30 @@ public class ExecutorsTest extends TestC
                 Executors.invoke(p,r);
             }
             
-            fail("should throw");
+            shouldThrow();
         } catch(ExecutionException success){
         } catch(Exception e){
-            fail("should throw EE");
+            unexpectedException();
         }
-        p.shutdownNow();
+        joinPool(p);
     }
 
 
 
     /**
-     *  Test to verify invoke(Executor, Callable) throws
+     *   invoke(Executor, Callable) throws
      *  InterruptedException A single use of invoke starts that will
      *  wait long enough for the invoking thread to be interrupted
      */
-    public void testInvoke5(){
-        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
+    public void testInvoke5() {
+        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
         
-        final Callable c = new Callable(){
-                public Object call(){
-                    try{
-                        Executors.invoke(p, new SleepCall());
-                        fail("should throw");
-                    }catch(InterruptedException e){}
+        final Callable c = new Callable() {
+                public Object call() {
+                    try {
+                        Executors.invoke(p, new SmallCallable());
+                        shouldThrow();
+                    } catch(InterruptedException e){}
                     catch(RejectedExecutionException e2){}
                     catch(ExecutionException e3){}
                     return Boolean.TRUE;
@@ -175,36 +206,36 @@ public class ExecutorsTest extends TestC
 
 
         
-        Thread t = new Thread(new Runnable(){
-                public void run(){
-                    try{
+        Thread t = new Thread(new Runnable() {
+                public void run() {
+                    try {
                         c.call();
-                    }catch(Exception e){}
+                    } catch(Exception e){}
                 }
           });
-        try{
+        try {
             t.start();
             Thread.sleep(SHORT_DELAY_MS);
             t.interrupt();
             t.join();
-        }catch(InterruptedException e){
-            fail("unexpected exception");
+        } catch(InterruptedException e){
+            unexpectedException();
         }
         
-        p.shutdownNow();
+        joinPool(p);
     }
 
     /**
-     *  Test to verify invoke(Executor, Callable) will throw ExecutionException
+     *   invoke(Executor, Callable) will throw ExecutionException
      *  An ExecutionException occurs when the underlying Runnable throws
      *  an exception, here the DivideByZeroException will cause an ExecutionException
      */
-    public void testInvoke6(){
-        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
+    public void testInvoke6() {
+        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
 
-        try{
-            Callable c = new Callable(){
-                    public Object call(){
+        try {
+            Callable c = new Callable() {
+                    public Object call() {
                         int i = 5/0;
                         return Boolean.TRUE;
                     }
@@ -214,108 +245,92 @@ public class ExecutorsTest extends TestC
                 Executors.invoke(p,c);
             }
             
-            fail("should throw");
-        }catch(RejectedExecutionException e){}
+            shouldThrow();
+        } catch(RejectedExecutionException e){}
         catch(InterruptedException e2){}
         catch(ExecutionException e3){}
-        p.shutdownNow();
+        joinPool(p);
     }
 
+    /**
+     *
+     */
     public void testExecuteRunnable () {
         try {
             Executor e = new DirectExecutor();
-            Task task = new Task();
-
-            assertFalse("task should not be complete", task.isCompleted());
-
+            MyTask task = new MyTask();
+            assertFalse(task.isCompleted());
             Future<String> future = Executors.execute(e, task, TEST_STRING);
             String result = future.get();
-
-            assertTrue("task should be complete", task.isCompleted());
-            assertSame("should return test string", TEST_STRING, result);
+            assertTrue(task.isCompleted());
+            assertSame(TEST_STRING, result);
         }
         catch (ExecutionException ex) {
-            fail("Unexpected exception");
+            unexpectedException();
         }
         catch (InterruptedException ex) {
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }
 
+    /**
+     *
+     */
     public void testInvokeRunnable () {
         try {
             Executor e = new DirectExecutor();
-            Task task = new Task();
-
-            assertFalse("task should not be complete", task.isCompleted());
-
+            MyTask task = new MyTask();
+            assertFalse(task.isCompleted());
             Executors.invoke(e, task);
-
-            assertTrue("task should be complete", task.isCompleted());
+            assertTrue(task.isCompleted());
         }
         catch (ExecutionException ex) {
-            fail("Unexpected exception");
+            unexpectedException();
         }
         catch (InterruptedException ex) {
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }
 
+    /**
+     *
+     */
     public void testExecuteCallable () {
         try {
             Executor e = new DirectExecutor();
             Future<String> future = Executors.execute(e, new StringTask());
             String result = future.get();
-
-            assertSame("should return test string", TEST_STRING, result);
+            assertSame(TEST_STRING, result);
         }
         catch (ExecutionException ex) {
-            fail("Unexpected exception");
+            unexpectedException();
         }
         catch (InterruptedException ex) {
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }
 
+    /**
+     *
+     */
     public void testInvokeCallable () {
         try {
             Executor e = new DirectExecutor();
             String result = Executors.invoke(e, new StringTask());
 
-            assertSame("should return test string", TEST_STRING, result);
+            assertSame(TEST_STRING, result);
         }
         catch (ExecutionException ex) {
-            fail("Unexpected exception" );
+            unexpectedException();
         }
         catch (InterruptedException ex) {
-            fail("Unexpected exception");
-        }
-    }
-
-    private static final String TEST_STRING = "a test string";
-
-    private static class Task implements Runnable {
-        public void run() { completed = true; }
-        public boolean isCompleted() { return completed; }
-        public void reset() { completed = false; }
-        private boolean completed = false;
-    }
-
-    private static class StringTask implements Callable<String> {
-        public String call() { return TEST_STRING; }
-    }
-
-    static class DirectExecutor implements Executor {
-        public void execute(Runnable r) {
-            r.run();
+            unexpectedException();
         }
     }
 
     /**
-     * Check that timeouts from execute will time out if they compute
-     * too long.
+     *  timeouts from execute will time out if they compute too long.
      */
-
     public void testTimedCallable() {
         int N = 10000;
         ExecutorService executor = Executors.newSingleThreadExecutor();
@@ -341,7 +356,7 @@ public class ExecutorsTest extends TestC
                     return;
                 }
                 catch (Exception e) {
-                    fail("unexpected exception: " + e);
+                    unexpectedException();
                 }
             }
             // if by chance we didn't ever time out, total time must be small
@@ -349,51 +364,11 @@ public class ExecutorsTest extends TestC
             assertTrue(elapsed < N);
         }
         finally {
-            executor.shutdownNow();
+            joinPool(executor);
         }
     }
 
     
-    static class TimedCallable<T> implements Callable<T> {
-        private final Executor exec;
-        private final Callable<T> func;
-        private final long msecs;
-        
-        TimedCallable(Executor exec, Callable<T> func, long msecs) {
-            this.exec = exec;
-            this.func = func;
-            this.msecs = msecs;
-        }
-        
-        public T call() throws Exception {
-            Future<T> ftask = Executors.execute(exec, func);
-            try {
-                return ftask.get(msecs, TimeUnit.MILLISECONDS);
-            } finally {
-                ftask.cancel(true);
-            }
-        }
-    }
-
-
-    private static class Fib implements Callable<BigInteger> {
-        private final BigInteger n;
-        Fib(long n) {
-            if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
-            this.n = BigInteger.valueOf(n);
-        }
-        public BigInteger call() {
-            BigInteger f1 = BigInteger.ONE;
-            BigInteger f2 = f1;
-            for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
-                BigInteger t = f1.add(f2);
-                f1 = f2;
-                f2 = t;
-            }
-            return f1;
-        }
-    };
-
 
 
 }