--- jsr166/src/test/tck/ExecutorsTest.java 2003/09/14 20:42:40 1.3 +++ jsr166/src/test/tck/ExecutorsTest.java 2006/04/03 15:00:59 1.17 @@ -1,8 +1,9 @@ /* - * Written by members of JCP JSR-166 Expert Group and released to the - * public domain. Use, modify, and redistribute this code in any way - * without acknowledgement. Other contributors include Andrew Wright, - * Jeffrey Hayes, Pat Fischer, Mike Judd. + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ @@ -10,284 +11,283 @@ import junit.framework.*; import java.util.*; import java.util.concurrent.*; import java.math.BigInteger; +import java.security.*; 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); + return new TestSuite(ExecutorsTest.class); } - /** - * 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, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(1)); - try{ - - for(int i = 0; i < 5; ++i){ - Executors.execute(p, new MediumRunnable(), Boolean.TRUE); + static class TimedCallable implements Callable { + private final ExecutorService exec; + private final Callable func; + private final long msecs; + + TimedCallable(ExecutorService exec, Callable func, long msecs) { + this.exec = exec; + this.func = func; + this.msecs = msecs; + } + + public T call() throws Exception { + Future ftask = exec.submit(func); + try { + return ftask.get(msecs, TimeUnit.MILLISECONDS); + } finally { + ftask.cancel(true); } - fail("should throw"); - } catch(RejectedExecutionException success){} - joinPool(p); + } } - /** - * 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, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(1)); - try{ - for(int i = 0; i < 5; ++i) { - Executors.execute(p, new SmallCallable()); + + private static class Fib implements Callable { + 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; } - fail("should throw"); - }catch(RejectedExecutionException e){} - joinPool(p); - } + 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()); + joinPool(e); + } /** - * 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,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(10)); - Thread t = new Thread(new Runnable() { - public void run(){ - try{ - Executors.invoke(p,new Runnable(){ - public void run(){ - try{ - Thread.sleep(MEDIUM_DELAY_MS); - fail("should throw"); - }catch(InterruptedException e){ - } - } - }); - } catch(InterruptedException success){ - } catch(Exception e) { - fail("unexpected exception"); - } - - } - }); - try{ - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - }catch(Exception e){ - fail("unexpected exception"); - } - joinPool(p); + * 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()); + joinPool(e); } /** - * 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,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(10)); - try{ - Runnable r = new Runnable(){ - public void run(){ - int i = 5/0; - } - }; - - for(int i =0; i < 5; i++){ - Executors.invoke(p,r); - } - - fail("should throw"); - } catch(ExecutionException success){ - } catch(Exception e){ - fail("should throw EE"); + * A newCachedThreadPool with null ThreadFactory throws NPE + */ + public void testNewCachedThreadPool3() { + try { + ExecutorService e = Executors.newCachedThreadPool(null); + shouldThrow(); + } + catch(NullPointerException success) { } - joinPool(p); } - /** - * invoke(Executor, Callable) throws - * InterruptedException A single use of invoke starts that will - * wait long enough for the invoking thread to be interrupted + * A new SingleThreadExecutor can execute runnables */ - public void testInvoke5(){ - final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(10)); - - final Callable c = new Callable(){ - public Object call(){ - try{ - Executors.invoke(p, new SmallCallable()); - fail("should throw"); - }catch(InterruptedException e){} - catch(RejectedExecutionException e2){} - catch(ExecutionException e3){} - return Boolean.TRUE; - } - }; + public void testNewSingleThreadExecutor1() { + ExecutorService e = Executors.newSingleThreadExecutor(); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + joinPool(e); + } + /** + * 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()); + joinPool(e); + } - - Thread t = new Thread(new Runnable(){ - public void run(){ - try{ - c.call(); - }catch(Exception e){} - } - }); - try{ - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - }catch(InterruptedException e){ - fail("unexpected exception"); + /** + * A new SingleThreadExecutor with null ThreadFactory throws NPE + */ + public void testNewSingleThreadExecutor3() { + try { + ExecutorService e = Executors.newSingleThreadExecutor(null); + shouldThrow(); + } + catch(NullPointerException success) { } - - joinPool(p); } /** - * invoke(Executor, Callable) will throw ExecutionException - * An ExecutionException occurs when the underlying Runnable throws - * an exception, here the DivideByZeroException will cause an ExecutionException + * A new SingleThreadExecutor cannot be casted to concrete implementation */ - public void testInvoke6(){ - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(10)); - - try{ - Callable c = new Callable(){ - public Object call(){ - int i = 5/0; - return Boolean.TRUE; - } - }; - - for(int i =0; i < 5; i++){ - Executors.invoke(p,c); - } - - fail("should throw"); - }catch(RejectedExecutionException e){} - catch(InterruptedException e2){} - catch(ExecutionException e3){} - joinPool(p); + public void testCastNewSingleThreadExecutor() { + ExecutorService e = Executors.newSingleThreadExecutor(); + try { + ThreadPoolExecutor tpe = (ThreadPoolExecutor)e; + } catch (ClassCastException success) { + } finally { + joinPool(e); + } } - public void testExecuteRunnable () { - try { - Executor e = new DirectExecutor(); - Task task = new Task(); - assertFalse("task should not be complete", task.isCompleted()); + /** + * 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()); + joinPool(e); + } - Future future = Executors.execute(e, task, TEST_STRING); - String result = future.get(); + /** + * 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()); + joinPool(e); + } - assertTrue("task should be complete", task.isCompleted()); - assertSame("should return test string", TEST_STRING, result); - } - catch (ExecutionException ex) { - fail("Unexpected exception"); + /** + * A new newFixedThreadPool with null ThreadFactory throws NPE + */ + public void testNewFixedThreadPool3() { + try { + ExecutorService e = Executors.newFixedThreadPool(2, null); + shouldThrow(); } - catch (InterruptedException ex) { - fail("Unexpected exception"); + catch(NullPointerException success) { } } - public void testInvokeRunnable () { + /** + * A new newFixedThreadPool with 0 threads throws IAE + */ + public void testNewFixedThreadPool4() { 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()); + ExecutorService e = Executors.newFixedThreadPool(0); + shouldThrow(); } - catch (ExecutionException ex) { - fail("Unexpected exception"); - } - catch (InterruptedException ex) { - fail("Unexpected exception"); + catch(IllegalArgumentException success) { } } - public void testExecuteCallable () { - try { - Executor e = new DirectExecutor(); - Future future = Executors.execute(e, new StringTask()); - String result = future.get(); - assertSame("should return test string", TEST_STRING, result); - } - catch (ExecutionException ex) { - fail("Unexpected exception"); + /** + * An unconfigurable newFixedThreadPool can execute runnables + */ + public void testunconfigurableExecutorService() { + ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2)); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + joinPool(e); + } + + /** + * unconfigurableExecutorService(null) throws NPE + */ + public void testunconfigurableExecutorServiceNPE() { + try { + ExecutorService e = Executors.unconfigurableExecutorService(null); } - catch (InterruptedException ex) { - fail("Unexpected exception"); + catch (NullPointerException success) { } } - public void testInvokeCallable () { + /** + * unconfigurableScheduledExecutorService(null) throws NPE + */ + public void testunconfigurableScheduledExecutorServiceNPE() { try { - Executor e = new DirectExecutor(); - String result = Executors.invoke(e, new StringTask()); - - assertSame("should return test string", TEST_STRING, result); + ExecutorService e = Executors.unconfigurableScheduledExecutorService(null); } - catch (ExecutionException ex) { - fail("Unexpected exception" ); - } - catch (InterruptedException ex) { - fail("Unexpected exception"); + catch (NullPointerException success) { } } - 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; + /** + * 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(); + } } - private static class StringTask implements Callable { - public String call() { return TEST_STRING; } + /** + * 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(); + } } - static class DirectExecutor implements Executor { - public void execute(Runnable r) { - r.run(); + /** + * 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(); } } /** - * 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(); @@ -313,7 +313,7 @@ public class ExecutorsTest extends JSR16 return; } catch (Exception e) { - fail("unexpected exception: " + e); + unexpectedException(); } } // if by chance we didn't ever time out, total time must be small @@ -326,46 +326,340 @@ public class ExecutorsTest extends JSR16 } - static class TimedCallable implements Callable { - private final Executor exec; - private final Callable func; - private final long msecs; + /** + * 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() { + 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 + } + } + }; + ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory()); - TimedCallable(Executor exec, Callable func, long msecs) { - this.exec = exec; - this.func = func; - this.msecs = msecs; + e.execute(r); + try { + e.shutdown(); + } catch(SecurityException ok) { } - public T call() throws Exception { - Future ftask = Executors.execute(exec, func); - try { - return ftask.get(msecs, TimeUnit.MILLISECONDS); - } finally { - ftask.cancel(true); - } + try { + Thread.sleep(SHORT_DELAY_MS); + } catch (Exception eX) { + unexpectedException(); + } finally { + joinPool(e); } } + /** + * ThreadPoolExecutor using privilegedThreadFactory has + * 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()); + + 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); + } - private static class Fib implements Callable { - 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); + } + + void checkCCL() { + AccessController.getContext().checkPermission(new RuntimePermission("getContextClassLoader")); + } + + class CheckCCL implements Callable { + public Object call() { + checkCCL(); + return null; } - 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; + } + + + /** + * Without class loader permissions, creating + * 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) { + } + + try { + Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable()); + shouldThrow(); + } catch(AccessControlException success) { + } catch(Exception ex) { + unexpectedException(); + } + finally { + Policy.setPolicy(savedPolicy); + } + } + + /** + * 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); + } + } + + /** + * 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(); + } + } + + /** + * 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); + } + } + + /** + * callable(Runnable) returns null when called + */ + public void testCallable1() { + try { + Callable c = Executors.callable(new NoOpRunnable()); + assertNull(c.call()); + } catch(Exception ex) { + unexpectedException(); + } + + } + + /** + * 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(); + } + } + + /** + * 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(); + } + } + + /** + * 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(); + } + } + + + /** + * callable(null Runnable) throws NPE + */ + public void testCallableNPE1() { + try { + Runnable r = null; + Callable c = Executors.callable(r); + } catch (NullPointerException success) { + } + } + + /** + * callable(null, result) throws NPE + */ + public void testCallableNPE2() { + try { + Runnable r = null; + Callable c = Executors.callable(r, one); + } catch (NullPointerException success) { + } + } + + /** + * callable(null PrivilegedAction) throws NPE + */ + public void testCallableNPE3() { + try { + PrivilegedAction r = null; + Callable c = Executors.callable(r); + } catch (NullPointerException success) { + } + } + + /** + * callable(null PrivilegedExceptionAction) throws NPE + */ + public void testCallableNPE4() { + try { + PrivilegedExceptionAction r = null; + Callable c = Executors.callable(r); + } catch (NullPointerException success) { + } + } }