--- jsr166/src/test/tck/ExecutorsTest.java	2003/08/31 19:24:55	1.1
+++ jsr166/src/test/tck/ExecutorsTest.java	2003/11/01 18:37:02	1.8
@@ -9,131 +9,511 @@
 import junit.framework.*;
 import java.util.*;
 import java.util.concurrent.*;
+import java.math.BigInteger;
+import java.security.*;
 
-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 StringTask implements Callable<String> {
+        public String call() { return TEST_STRING; }
+    }
+
+    static class DirectExecutor implements Executor {
+        public void execute(Runnable r) {
+            r.run();
+        }
+    }
+
+    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);
             }
         }
     }
-    
 
-    class SleepCall implements Callable {
-        public Object call(){
-            try{
-                Thread.sleep(MEDIUM_DELAY_MS);
-            }catch(InterruptedException e){
-                fail("unexpected exception");
+
+    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 Boolean.TRUE;
+            return f1;
+        }
+    };
+
+    /**
+     * A newCachedThreadPool can execute runnables
+     */
+    public void testNewCachedThreadPool1() {
+        ExecutorService e = Executors.newCachedThreadPool();
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.shutdown();
+    }
+
+    /**
+     * A newCachedThreadPool with given ThreadFactory can execute runnables
+     */
+    public void testNewCachedThreadPool2() {
+        ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.shutdown();
+    }
+
+    /**
+     * A newCachedThreadPool with null ThreadFactory throws NPE
+     */
+    public void testNewCachedThreadPool3() {
+        try {
+            ExecutorService e = Executors.newCachedThreadPool(null);
+            shouldThrow();
+        }
+        catch(NullPointerException success) {
+        }
+    }
+
+
+    /**
+     * A new SingleThreadExecutor can execute runnables
+     */
+    public void testNewSingleThreadExecutor1() {
+        ExecutorService e = Executors.newSingleThreadExecutor();
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.shutdown();
+    }
+
+    /**
+     * A new SingleThreadExecutor with given ThreadFactory can execute runnables
+     */
+    public void testNewSingleThreadExecutor2() {
+        ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.shutdown();
+    }
+
+    /**
+     * A new SingleThreadExecutor with null ThreadFactory throws NPE
+     */
+    public void testNewSingleThreadExecutor3() {
+        try {
+            ExecutorService e = Executors.newSingleThreadExecutor(null);
+            shouldThrow();
+        }
+        catch(NullPointerException success) {
         }
     }
 
+    /**
+     * A new newFixedThreadPool can execute runnables
+     */
+    public void testNewFixedThreadPool1() {
+        ExecutorService e = Executors.newFixedThreadPool(2);
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.shutdown();
+    }
 
+    /**
+     * A new newFixedThreadPool with given ThreadFactory can execute runnables
+     */
+    public void testNewFixedThreadPool2() {
+        ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.execute(new NoOpRunnable());
+        e.shutdown();
+    }
+
+    /**
+     * A new newFixedThreadPool with null ThreadFactory throws NPE
+     */
+    public void testNewFixedThreadPool3() {
+        try {
+            ExecutorService e = Executors.newFixedThreadPool(2, null);
+            shouldThrow();
+        }
+        catch(NullPointerException success) {
+        }
+    }
+
+    /**
+     * A new newFixedThreadPool with 0 threads throws IAE
+     */
+    public void testNewFixedThreadPool4() {
+        try {
+            ExecutorService e = Executors.newFixedThreadPool(0);
+            shouldThrow();
+        }
+        catch(IllegalArgumentException success) {
+        }
+    }
 
     /**
-     *  Test to verify 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
+     * execute of runnable runs it to completion 
      */
-    public void testExecute1(){
-        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
-        try{
+    public void testExecuteRunnable() {
+        try {
+            Executor e = new DirectExecutor();
+            TrackedShortRunnable task = new TrackedShortRunnable();
+            assertFalse(task.done);
+            Future<String> future = Executors.execute(e, task, TEST_STRING);
+            String result = future.get();
+            assertTrue(task.done);
+            assertSame(TEST_STRING, result);
+        }
+        catch (ExecutionException ex) {
+            unexpectedException();
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * invoke of a runnable runs it to completion 
+     */
+    public void testInvokeRunnable() {
+        try {
+            Executor e = new DirectExecutor();
+            TrackedShortRunnable task = new TrackedShortRunnable();
+            assertFalse(task.done);
+            Executors.invoke(e, task);
+            assertTrue(task.done);
+        }
+        catch (ExecutionException ex) {
+            unexpectedException();
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * execute of a callable runs it to completion
+     */
+    public void testExecuteCallable() {
+        try {
+            Executor e = new DirectExecutor();
+            Future<String> future = Executors.execute(e, new StringTask());
+            String result = future.get();
+            assertSame(TEST_STRING, result);
+        }
+        catch (ExecutionException ex) {
+            unexpectedException();
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+    }
+
+
+    /**
+     * execute of a privileged action runs it to completion
+     */
+    public void testExecutePrivilegedAction() {
+	Policy savedPolicy = Policy.getPolicy();
+        AdjustablePolicy policy = new AdjustablePolicy();
+        policy.addPermission(new RuntimePermission("getContextClassLoader"));
+        policy.addPermission(new RuntimePermission("setContextClassLoader"));
+	Policy.setPolicy(policy);
+        try {
+            Executor e = new DirectExecutor();
+            Future future = Executors.execute(e, new PrivilegedAction() {
+		    public Object run() {
+			return TEST_STRING;
+		    }});
+
+            Object result = future.get();
+            assertSame(TEST_STRING, result);
+        }
+        catch (ExecutionException ex) {
+            unexpectedException();
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+	finally {
+	    Policy.setPolicy(savedPolicy);
+	}
+    }
+
+    /**
+     * execute of a privileged exception action runs it to completion
+     */
+    public void testExecutePrivilegedExceptionAction() {
+	Policy savedPolicy = Policy.getPolicy();
+        AdjustablePolicy policy = new AdjustablePolicy();
+        policy.addPermission(new RuntimePermission("getContextClassLoader"));
+        policy.addPermission(new RuntimePermission("setContextClassLoader"));
+	Policy.setPolicy(policy);
+        try {
+            Executor e = new DirectExecutor();
+            Future future = Executors.execute(e, new PrivilegedExceptionAction() {
+		    public Object run() {
+			return TEST_STRING;
+		    }});
+
+            Object result = future.get();
+            assertSame(TEST_STRING, result);
+        }
+        catch (ExecutionException ex) {
+            unexpectedException();
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+	finally {
+	    Policy.setPolicy(savedPolicy);
+	}
+    }
+
+    /**
+     * execute of a failed privileged exception action reports exception
+     */
+    public void testExecuteFailedPrivilegedExceptionAction() {
+	Policy savedPolicy = Policy.getPolicy();
+        AdjustablePolicy policy = new AdjustablePolicy();
+        policy.addPermission(new RuntimePermission("getContextClassLoader"));
+        policy.addPermission(new RuntimePermission("setContextClassLoader"));
+	Policy.setPolicy(policy);
+        try {
+            Executor e = new DirectExecutor();
+            Future future = Executors.execute(e, new PrivilegedExceptionAction() {
+		    public Object run() throws Exception {
+			throw new IndexOutOfBoundsException();
+		    }});
+
+            Object result = future.get();
+            shouldThrow();
+        }
+        catch (ExecutionException success) {
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+	finally {
+	    Policy.setPolicy(savedPolicy);
+	}
+    }
+
+    /**
+     * invoke of a collable runs it to completion
+     */
+    public void testInvokeCallable() {
+        try {
+            Executor e = new DirectExecutor();
+            String result = Executors.invoke(e, new StringTask());
+
+            assertSame(TEST_STRING, result);
+        }
+        catch (ExecutionException ex) {
+            unexpectedException();
+        }
+        catch (InterruptedException ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * execute with null executor throws NPE
+     */
+    public void testNullExecuteRunnable() {
+        try {
+            TrackedShortRunnable task = new TrackedShortRunnable();
+            assertFalse(task.done);
+            Future<String> future = Executors.execute(null, task, TEST_STRING);
+            shouldThrow();
+        }
+        catch (NullPointerException success) {
+        }
+        catch (Exception ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * execute with a null runnable throws NPE
+     */
+    public void testExecuteNullRunnable() {
+        try {
+            Executor e = new DirectExecutor();
+            TrackedShortRunnable task = null;
+            Future<String> future = Executors.execute(e, task, TEST_STRING);
+            shouldThrow();
+        }
+        catch (NullPointerException success) {
+        }
+        catch (Exception ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * invoke of a null runnable throws NPE
+     */
+    public void testInvokeNullRunnable() {
+        try {
+            Executor e = new DirectExecutor();
+            TrackedShortRunnable task = null;
+            Executors.invoke(e, task);
+            shouldThrow();
+        }
+        catch (NullPointerException success) {
+        }
+        catch (Exception ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * execute of a null callable throws NPE
+     */
+    public void testExecuteNullCallable() {
+        try {
+            Executor e = new DirectExecutor();
+            StringTask t = null;
+            Future<String> future = Executors.execute(e, t);
+            shouldThrow();
+        }
+        catch (NullPointerException success) {
+        }
+        catch (Exception ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * invoke of a null callable throws NPE
+     */
+    public void testInvokeNullCallable() {
+        try {
+            Executor e = new DirectExecutor();
+            StringTask t = null;
+            String result = Executors.invoke(e, t);
+            shouldThrow();
+        }
+        catch (NullPointerException success) {
+        }
+        catch (Exception ex) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     *  execute(Executor, Runnable) throws RejectedExecutionException
+     *  if saturated.
+     */
+    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
-     *  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
+     *  execute(Executor, Callable)throws RejectedExecutionException
+     *  if saturated.
      */
-    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
-     *  A single use of invoke starts that will wait long enough
-     *  for the invoking thread to be interrupted
+     *  invoke(Executor, Runnable) throws InterruptedException if
+     *  caller interrupted.
      */
-    public void testInvoke2(){
-        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
+    public void testInterruptedInvoke() {
+        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
-     *  ExecutionException An ExecutionException occurs when the
-     *  underlying Runnable throws an exception, here the
-     *  DivideByZeroException will cause an ExecutionException
+     *  invoke(Executor, Runnable) throws ExecutionException if
+     *  runnable throws exception.
      */
-    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;
                     }
                 };
@@ -142,30 +522,29 @@ 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
-     *  InterruptedException A single use of invoke starts that will
-     *  wait long enough for the invoking thread to be interrupted
+     *  invoke(Executor, Callable) throws InterruptedException if
+     *  callable throws exception
      */
-    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;
@@ -174,36 +553,35 @@ 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
-     *  An ExecutionException occurs when the underlying Runnable throws
-     *  an exception, here the DivideByZeroException will cause an ExecutionException
+     *  invoke(Executor, Callable) will throw ExecutionException
+     *  if callable throws exception
      */
-    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;
                     }
@@ -213,102 +591,136 @@ public class ExecutorsTest extends TestC
                 Executors.invoke(p,c);
             }
             
-            fail("should throw");
-        }catch(RejectedExecutionException e){}
-        catch(InterruptedException e2){}
-        catch(ExecutionException e3){}
-        p.shutdownNow();
-    }
-
-    public void testExecuteRunnable () {
-        try {
-            Executor e = new DirectExecutor();
-            Task task = new Task();
-
-            assertFalse("task should not be complete", 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);
-        }
-        catch (ExecutionException ex) {
-            fail("Unexpected exception");
-        }
-        catch (InterruptedException ex) {
-            fail("Unexpected exception");
+            shouldThrow();
+        } 
+        catch(ExecutionException success){
+        } catch(Exception e) {
+            unexpectedException();
         }
+        joinPool(p);
     }
 
-    public void testInvokeRunnable () {
-        try {
-            Executor e = new DirectExecutor();
-            Task task = new Task();
 
-            assertFalse("task should not be complete", task.isCompleted());
 
-            Executors.invoke(e, task);
-
-            assertTrue("task should be complete", task.isCompleted());
-        }
-        catch (ExecutionException ex) {
-            fail("Unexpected exception");
-        }
-        catch (InterruptedException ex) {
-            fail("Unexpected exception");
-        }
-    }
-
-    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);
-        }
-        catch (ExecutionException ex) {
-            fail("Unexpected exception");
-        }
-        catch (InterruptedException ex) {
-            fail("Unexpected exception");
-        }
-    }
-
-    public void testInvokeCallable () {
+    /**
+     *  timeouts from execute will time out if they compute too long.
+     */
+    public void testTimedCallable() {
+        int N = 10000;
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
         try {
-            Executor e = new DirectExecutor();
-            String result = Executors.invoke(e, new StringTask());
-
-            assertSame("should return test string", TEST_STRING, result);
-        }
-        catch (ExecutionException ex) {
-            fail("Unexpected exception" );
+            long startTime = System.currentTimeMillis();
+            
+            long i = 0;
+            while (tasks.size() < N) {
+                tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
+                i += 10;
+            }
+            
+            int iters = 0;
+            BigInteger sum = BigInteger.ZERO;
+            for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
+                try {
+                    ++iters;
+                    sum = sum.add(it.next().call());
+                }
+                catch (TimeoutException success) {
+                    assertTrue(iters > 0);
+                    return;
+                }
+                catch (Exception e) {
+                    unexpectedException();
+                }
+            }
+            // if by chance we didn't ever time out, total time must be small
+            long elapsed = System.currentTimeMillis() - startTime;
+            assertTrue(elapsed < N);
         }
-        catch (InterruptedException ex) {
-            fail("Unexpected exception");
+        finally {
+            joinPool(executor);
         }
     }
 
-    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;
+    
+    /**
+     * ThreadPoolExecutor using defaultThreadFactory has
+     * specified group, priority, daemon status, and name
+     */
+    public void testDefaultThreadFactory() {
+	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
+	Runnable r = new Runnable() {
+		public void run() {
+		    Thread current = Thread.currentThread();
+		    threadAssertTrue(!current.isDaemon());
+		    threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
+		    ThreadGroup g = current.getThreadGroup();
+		    SecurityManager s = System.getSecurityManager();
+		    if (s != null)
+			threadAssertTrue(g == s.getThreadGroup());
+		    else
+			threadAssertTrue(g == egroup);
+		    String name = current.getName();
+		    threadAssertTrue(name.endsWith("thread-1"));
+		}
+	    };
+	ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
+	
+	e.execute(r);
+	e.shutdown();
+	try {
+	    Thread.sleep(SHORT_DELAY_MS);
+	} catch (Exception eX) {
+	    unexpectedException();
+	} finally {
+	    joinPool(e);
+	}
     }
 
-    private static class StringTask implements Callable<String> {
-        public String call() { return TEST_STRING; }
-    }
+    /**
+     * ThreadPoolExecutor using privilegedThreadFactory has
+     * specified group, priority, daemon status, name,
+     * access control context and context class loader
+     */
+    public void testPrivilegedThreadFactory() {
+	Policy savedPolicy = Policy.getPolicy();
+        AdjustablePolicy policy = new AdjustablePolicy();
+        policy.addPermission(new RuntimePermission("getContextClassLoader"));
+        policy.addPermission(new RuntimePermission("setContextClassLoader"));
+	Policy.setPolicy(policy);
+	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
+	final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
+        final AccessControlContext thisacc = AccessController.getContext();
+	Runnable r = new Runnable() {
+		public void run() {
+		    Thread current = Thread.currentThread();
+		    threadAssertTrue(!current.isDaemon());
+		    threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
+		    ThreadGroup g = current.getThreadGroup();
+		    SecurityManager s = System.getSecurityManager();
+		    if (s != null)
+			threadAssertTrue(g == s.getThreadGroup());
+		    else
+			threadAssertTrue(g == egroup);
+		    String name = current.getName();
+		    threadAssertTrue(name.endsWith("thread-1"));
+		    threadAssertTrue(thisccl == current.getContextClassLoader());
+		    threadAssertTrue(thisacc.equals(AccessController.getContext()));
+		}
+	    };
+	ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
+	
+	Policy.setPolicy(savedPolicy);
+	e.execute(r);
+	e.shutdown();
+	try {
+	    Thread.sleep(SHORT_DELAY_MS);
+	} catch (Exception ex) {
+	    unexpectedException();
+	} finally {
+	    joinPool(e);
+	}
 
-    static class DirectExecutor implements Executor {
-        public void execute(Runnable r) {
-            r.run();
-        }
     }
 
-
 }