--- jsr166/src/test/tck/ExecutorsTest.java	2009/11/16 04:57:10	1.21
+++ jsr166/src/test/tck/ExecutorsTest.java	2010/10/09 19:30:35	1.34
@@ -10,57 +10,18 @@
 import junit.framework.*;
 import java.util.*;
 import java.util.concurrent.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import java.math.BigInteger;
 import java.security.*;
 
-public class ExecutorsTest extends JSR166TestCase{
+public class ExecutorsTest 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(ExecutorsTest.class);
     }
 
-    static class TimedCallable<T> implements Callable<T> {
-        private final ExecutorService exec;
-        private final Callable<T> func;
-        private final long msecs;
-
-        TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
-            this.exec = exec;
-            this.func = func;
-            this.msecs = msecs;
-        }
-
-        public T call() throws Exception {
-            Future<T> ftask = exec.submit(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;
-        }
-    };
-
     /**
      * A newCachedThreadPool can execute runnables
      */
@@ -90,9 +51,7 @@ public class ExecutorsTest extends JSR16
         try {
             ExecutorService e = Executors.newCachedThreadPool(null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
 
@@ -125,9 +84,7 @@ public class ExecutorsTest extends JSR16
         try {
             ExecutorService e = Executors.newSingleThreadExecutor(null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -137,6 +94,7 @@ public class ExecutorsTest extends JSR16
         ExecutorService e = Executors.newSingleThreadExecutor();
         try {
             ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
+            shouldThrow();
         } catch (ClassCastException success) {
         } finally {
             joinPool(e);
@@ -173,9 +131,7 @@ public class ExecutorsTest extends JSR16
         try {
             ExecutorService e = Executors.newFixedThreadPool(2, null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -185,9 +141,7 @@ public class ExecutorsTest extends JSR16
         try {
             ExecutorService e = Executors.newFixedThreadPool(0);
             shouldThrow();
-        }
-        catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
 
@@ -208,9 +162,8 @@ public class ExecutorsTest extends JSR16
     public void testunconfigurableExecutorServiceNPE() {
         try {
             ExecutorService e = Executors.unconfigurableExecutorService(null);
-        }
-        catch (NullPointerException success) {
-        }
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -219,109 +172,81 @@ public class ExecutorsTest extends JSR16
     public void testunconfigurableScheduledExecutorServiceNPE() {
         try {
             ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
-        }
-        catch (NullPointerException success) {
-        }
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
 
     /**
      * a newSingleThreadScheduledExecutor successfully runs delayed task
      */
-    public void testNewSingleThreadScheduledExecutor() {
-	try {
-            TrackedCallable callable = new TrackedCallable();
-            ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
-	    Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-	    assertFalse(callable.done);
-	    Thread.sleep(MEDIUM_DELAY_MS);
-	    assertTrue(callable.done);
-	    assertEquals(Boolean.TRUE, f.get());
-            joinPool(p1);
-	} catch (RejectedExecutionException e){}
-	catch (Exception e){
-            e.printStackTrace();
-            unexpectedException();
-        }
+    public void testNewSingleThreadScheduledExecutor() throws Exception {
+        TrackedCallable callable = new TrackedCallable();
+        ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
+        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
+        assertFalse(callable.done);
+        Thread.sleep(MEDIUM_DELAY_MS);
+        assertTrue(callable.done);
+        assertEquals(Boolean.TRUE, f.get());
+        joinPool(p1);
     }
 
     /**
      * a newScheduledThreadPool successfully runs delayed task
      */
-    public void testnewScheduledThreadPool() {
-	try {
-            TrackedCallable callable = new TrackedCallable();
-            ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
-	    Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-	    assertFalse(callable.done);
-	    Thread.sleep(MEDIUM_DELAY_MS);
-	    assertTrue(callable.done);
-	    assertEquals(Boolean.TRUE, f.get());
-            joinPool(p1);
-	} catch (RejectedExecutionException e){}
-	catch (Exception e){
-            e.printStackTrace();
-            unexpectedException();
-        }
+    public void testnewScheduledThreadPool() throws Exception {
+        TrackedCallable callable = new TrackedCallable();
+        ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
+        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
+        assertFalse(callable.done);
+        Thread.sleep(MEDIUM_DELAY_MS);
+        assertTrue(callable.done);
+        assertEquals(Boolean.TRUE, f.get());
+        joinPool(p1);
     }
 
     /**
-     * an unconfigurable  newScheduledThreadPool successfully runs delayed task
-     */
-    public void testunconfigurableScheduledExecutorService() {
-	try {
-            TrackedCallable callable = new TrackedCallable();
-            ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
-	    Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-	    assertFalse(callable.done);
-	    Thread.sleep(MEDIUM_DELAY_MS);
-	    assertTrue(callable.done);
-	    assertEquals(Boolean.TRUE, f.get());
-            joinPool(p1);
-	} catch (RejectedExecutionException e){}
-	catch (Exception e){
-            e.printStackTrace();
-            unexpectedException();
-        }
+     * an unconfigurable newScheduledThreadPool successfully runs delayed task
+     */
+    public void testunconfigurableScheduledExecutorService() throws Exception {
+        TrackedCallable callable = new TrackedCallable();
+        ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
+        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
+        assertFalse(callable.done);
+        Thread.sleep(MEDIUM_DELAY_MS);
+        assertTrue(callable.done);
+        assertEquals(Boolean.TRUE, f.get());
+        joinPool(p1);
     }
 
     /**
-     *  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 {
-            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();) {
+     * Future.get on submitted tasks will time out if they compute too long.
+     */
+    public void testTimedCallable() throws Exception {
+        final Runnable sleeper = new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                Thread.sleep(LONG_DELAY_MS);
+            }};
+        for (ExecutorService executor :
+                 new ExecutorService[] {
+                     Executors.newSingleThreadExecutor(),
+                     Executors.newCachedThreadPool(),
+                     Executors.newFixedThreadPool(2),
+                     Executors.newScheduledThreadPool(2),
+                 }) {
+            try {
+                Future future = executor.submit(sleeper);
                 try {
-                    ++iters;
-                    sum = sum.add(it.next().call());
-                }
-                catch (TimeoutException success) {
-                    assertTrue(iters > 0);
-                    return;
-                }
-                catch (Exception e) {
-                    unexpectedException();
+                    future.get(SHORT_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (TimeoutException success) {
+                } finally {
+                    future.cancel(true);
                 }
             }
-            // if by chance we didn't ever time out, total time must be small
-            long elapsed = System.currentTimeMillis() - startTime;
-            assertTrue(elapsed < N);
-        }
-        finally {
-            joinPool(executor);
+            finally {
+                joinPool(executor);
+            }
         }
     }
 
@@ -330,27 +255,26 @@ public class ExecutorsTest extends JSR16
      * ThreadPoolExecutor using defaultThreadFactory has
      * specified group, priority, daemon status, and name
      */
-    public void testDefaultThreadFactory() {
+    public void testDefaultThreadFactory() throws Exception {
         final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
-        Runnable r = new Runnable() {
-                public void run() {
-		    try {
-			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"));
-		    } catch (SecurityException ok) {
-			// Also pass if not allowed to change setting
-		    }
+        Runnable r = new CheckedRunnable() {
+            public void realRun() {
+                try {
+                    Thread current = Thread.currentThread();
+                    assertTrue(!current.isDaemon());
+                    assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
+                    ThreadGroup g = current.getThreadGroup();
+                    SecurityManager s = System.getSecurityManager();
+                    if (s != null)
+                        assertTrue(g == s.getThreadGroup());
+                    else
+                        assertTrue(g == egroup);
+                    String name = current.getName();
+                    assertTrue(name.endsWith("thread-1"));
+                } catch (SecurityException ok) {
+                    // Also pass if not allowed to change setting
                 }
-            };
+            }};
         ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
 
         e.execute(r);
@@ -361,8 +285,6 @@ public class ExecutorsTest extends JSR16
 
         try {
             Thread.sleep(SHORT_DELAY_MS);
-        } catch (Exception eX) {
-            unexpectedException();
         } finally {
             joinPool(e);
         }
@@ -373,57 +295,52 @@ public class ExecutorsTest extends JSR16
      * specified group, priority, daemon status, name,
      * access control context and context class loader
      */
-    public void testPrivilegedThreadFactory() {
-        Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            policy.addPermission(new RuntimePermission("getContextClassLoader"));
-            policy.addPermission(new RuntimePermission("setContextClassLoader"));
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
-        final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
-        final AccessControlContext thisacc = AccessController.getContext();
-        Runnable r = new Runnable() {
-                public void run() {
-		    try {
-			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()));
-		    } catch (SecurityException ok) {
-			// Also pass if not allowed to change settings
-		    }
-                }
-            };
-        ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
+    public void testPrivilegedThreadFactory() throws Exception {
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
+                final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
+                final AccessControlContext thisacc = AccessController.getContext();
+                Runnable r = new CheckedRunnable() {
+                    public void realRun() {
+                        Thread current = Thread.currentThread();
+                        assertTrue(!current.isDaemon());
+                        assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
+                        ThreadGroup g = current.getThreadGroup();
+                        SecurityManager s = System.getSecurityManager();
+                        if (s != null)
+                            assertTrue(g == s.getThreadGroup());
+                        else
+                            assertTrue(g == egroup);
+                        String name = current.getName();
+                        assertTrue(name.endsWith("thread-1"));
+                        assertSame(thisccl, current.getContextClassLoader());
+                        assertEquals(thisacc, AccessController.getContext());
+                    }};
+                ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
+                e.execute(r);
+                e.shutdown();
+                Thread.sleep(SHORT_DELAY_MS);
+                joinPool(e);
+            }};
+
+        runWithPermissions(r,
+                           new RuntimePermission("getClassLoader"),
+                           new RuntimePermission("setContextClassLoader"),
+                           new RuntimePermission("modifyThread"));
+    }
 
-        Policy.setPolicy(savedPolicy);
-        e.execute(r);
-        try {
-            e.shutdown();
-        } catch (SecurityException ok) {
-        }
-        try {
-            Thread.sleep(SHORT_DELAY_MS);
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    boolean haveCCLPermissions() {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            try {
+                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
+                sm.checkPermission(new RuntimePermission("getClassLoader"));
+            } catch (AccessControlException e) {
+                return false;
+            }
         }
-
+        return true;
     }
 
     void checkCCL() {
@@ -447,177 +364,154 @@ public class ExecutorsTest extends JSR16
      * privilegedCallableUsingCurrentClassLoader throws ACE
      */
     public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
-	Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-
-        // Check if program still has too many permissions to run test
-        try {
-            checkCCL();
-            // too many privileges to test; so return
-            Policy.setPolicy(savedPolicy);
-            return;
-        } catch (AccessControlException ok) {
-        }
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                if (System.getSecurityManager() == null)
+                    return;
+                try {
+                    Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
+                    shouldThrow();
+                } catch (AccessControlException success) {}
+            }};
 
-        try {
-            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
-            shouldThrow();
-        } catch (AccessControlException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
-        finally {
-            Policy.setPolicy(savedPolicy);
-        }
+        runWithoutPermissions(r);
     }
 
     /**
      * With class loader permissions, calling
      * privilegedCallableUsingCurrentClassLoader does not throw ACE
      */
-    public void testprivilegedCallableUsingCCLWithPrivs() {
-	Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            policy.addPermission(new RuntimePermission("getContextClassLoader"));
-            policy.addPermission(new RuntimePermission("setContextClassLoader"));
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-
-        try {
-            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
-            task.call();
-        } catch (Exception ex) {
-            unexpectedException();
-        }
-        finally {
-            Policy.setPolicy(savedPolicy);
-        }
+    public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                Executors.privilegedCallableUsingCurrentClassLoader
+                    (new NoOpCallable())
+                    .call();
+            }};
+
+        runWithPermissions(r,
+                           new RuntimePermission("getClassLoader"),
+                           new RuntimePermission("setContextClassLoader"));
     }
 
     /**
      * Without permissions, calling privilegedCallable throws ACE
      */
-    public void testprivilegedCallableWithNoPrivs() {
-        Callable task;
-        Policy savedPolicy = null;
-        AdjustablePolicy policy = null;
-        AccessControlContext noprivAcc = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            policy = new AdjustablePolicy();
-            Policy.setPolicy(policy);
-            noprivAcc = AccessController.getContext();
-            task = Executors.privilegedCallable(new CheckCCL());
-            Policy.setPolicy(savedPolicy);
-        } catch (AccessControlException ok) {
-            return; // program has too few permissions to set up test
-        }
-
-        // Make sure that program doesn't have too many permissions
-        try {
-            AccessController.doPrivileged(new PrivilegedAction() {
-                    public Object run() {
-                        checkCCL();
-                        return null;
-                    }}, noprivAcc);
-            // too many permssions; skip test
-            return;
-        } catch (AccessControlException ok) {
-        }
-
-        try {
-            task.call();
-            shouldThrow();
-        } catch (AccessControlException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+    public void testprivilegedCallableWithNoPrivs() throws Exception {
+        // Avoid classloader-related SecurityExceptions in swingui.TestRunner
+        Executors.privilegedCallable(new CheckCCL());
+
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                if (System.getSecurityManager() == null)
+                    return;
+                Callable task = Executors.privilegedCallable(new CheckCCL());
+                try {
+                    task.call();
+                    shouldThrow();
+                } catch (AccessControlException success) {}
+            }};
+
+        runWithoutPermissions(r);
+
+        // It seems rather difficult to test that the
+        // AccessControlContext of the privilegedCallable is used
+        // instead of its caller.  Below is a failed attempt to do
+        // that, which does not work because the AccessController
+        // cannot capture the internal state of the current Policy.
+        // It would be much more work to differentiate based on,
+        // e.g. CodeSource.
+
+//         final AccessControlContext[] noprivAcc = new AccessControlContext[1];
+//         final Callable[] task = new Callable[1];
+
+//         runWithPermissions
+//             (new CheckedRunnable() {
+//                 public void realRun() {
+//                     if (System.getSecurityManager() == null)
+//                         return;
+//                     noprivAcc[0] = AccessController.getContext();
+//                     task[0] = Executors.privilegedCallable(new CheckCCL());
+//                     try {
+//                         AccessController.doPrivileged(new PrivilegedAction<Void>() {
+//                                                           public Void run() {
+//                                                               checkCCL();
+//                                                               return null;
+//                                                           }}, noprivAcc[0]);
+//                         shouldThrow();
+//                     } catch (AccessControlException success) {}
+//                 }});
+
+//         runWithPermissions
+//             (new CheckedRunnable() {
+//                 public void realRun() throws Exception {
+//                     if (System.getSecurityManager() == null)
+//                         return;
+//                     // Verify that we have an underprivileged ACC
+//                     try {
+//                         AccessController.doPrivileged(new PrivilegedAction<Void>() {
+//                                                           public Void run() {
+//                                                               checkCCL();
+//                                                               return null;
+//                                                           }}, noprivAcc[0]);
+//                         shouldThrow();
+//                     } catch (AccessControlException success) {}
+
+//                     try {
+//                         task[0].call();
+//                         shouldThrow();
+//                     } catch (AccessControlException success) {}
+//                 }},
+//              new RuntimePermission("getClassLoader"),
+//              new RuntimePermission("setContextClassLoader"));
     }
 
     /**
      * With permissions, calling privilegedCallable succeeds
      */
-    public void testprivilegedCallableWithPrivs() {
-	Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            policy.addPermission(new RuntimePermission("getContextClassLoader"));
-            policy.addPermission(new RuntimePermission("setContextClassLoader"));
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-
-        Callable task = Executors.privilegedCallable(new CheckCCL());
-        try {
-            task.call();
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            Policy.setPolicy(savedPolicy);
-        }
+    public void testprivilegedCallableWithPrivs() throws Exception {
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                Executors.privilegedCallable(new CheckCCL()).call();
+            }};
+
+         runWithPermissions(r,
+                           new RuntimePermission("getClassLoader"),
+                           new RuntimePermission("setContextClassLoader"));
     }
 
     /**
      * callable(Runnable) returns null when called
      */
-    public void testCallable1() {
-        try {
-            Callable c = Executors.callable(new NoOpRunnable());
-            assertNull(c.call());
-        } catch (Exception ex) {
-            unexpectedException();
-        }
-
+    public void testCallable1() throws Exception {
+        Callable c = Executors.callable(new NoOpRunnable());
+        assertNull(c.call());
     }
 
     /**
      * callable(Runnable, result) returns result when called
      */
-    public void testCallable2() {
-        try {
-            Callable c = Executors.callable(new NoOpRunnable(), one);
-            assertEquals(one, c.call());
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+    public void testCallable2() throws Exception {
+        Callable c = Executors.callable(new NoOpRunnable(), one);
+        assertSame(one, c.call());
     }
 
     /**
      * callable(PrivilegedAction) returns its result when called
      */
-    public void testCallable3() {
-        try {
-            Callable c = Executors.callable(new PrivilegedAction() {
-                    public Object run() { return one; }});
-        assertEquals(one, c.call());
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+    public void testCallable3() throws Exception {
+        Callable c = Executors.callable(new PrivilegedAction() {
+                public Object run() { return one; }});
+        assertSame(one, c.call());
     }
 
     /**
      * callable(PrivilegedExceptionAction) returns its result when called
      */
-    public void testCallable4() {
-        try {
-            Callable c = Executors.callable(new PrivilegedExceptionAction() {
-                    public Object run() { return one; }});
-            assertEquals(one, c.call());
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+    public void testCallable4() throws Exception {
+        Callable c = Executors.callable(new PrivilegedExceptionAction() {
+                public Object run() { return one; }});
+        assertSame(one, c.call());
     }
 
 
@@ -626,10 +520,9 @@ public class ExecutorsTest extends JSR16
      */
     public void testCallableNPE1() {
         try {
-            Runnable r = null;
-            Callable c = Executors.callable(r);
-        } catch (NullPointerException success) {
-        }
+            Callable c = Executors.callable((Runnable) null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -637,10 +530,9 @@ public class ExecutorsTest extends JSR16
      */
     public void testCallableNPE2() {
         try {
-            Runnable r = null;
-            Callable c = Executors.callable(r, one);
-        } catch (NullPointerException success) {
-        }
+            Callable c = Executors.callable((Runnable) null, one);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -648,10 +540,9 @@ public class ExecutorsTest extends JSR16
      */
     public void testCallableNPE3() {
         try {
-            PrivilegedAction r = null;
-            Callable c = Executors.callable(r);
-        } catch (NullPointerException success) {
-        }
+            Callable c = Executors.callable((PrivilegedAction) null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -659,10 +550,9 @@ public class ExecutorsTest extends JSR16
      */
     public void testCallableNPE4() {
         try {
-            PrivilegedExceptionAction r = null;
-            Callable c = Executors.callable(r);
-        } catch (NullPointerException success) {
-        }
+            Callable c = Executors.callable((PrivilegedExceptionAction) null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }