--- jsr166/src/test/tck/ExecutorsTest.java 2004/01/20 20:20:56 1.14 +++ jsr166/src/test/tck/ExecutorsTest.java 2009/11/21 02:33:20 1.26 @@ -2,20 +2,21 @@ * 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. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ 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); @@ -25,17 +26,17 @@ public class ExecutorsTest extends JSR16 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); + return ftask.get(msecs, MILLISECONDS); } finally { ftask.cancel(true); } @@ -90,9 +91,7 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newCachedThreadPool(null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } @@ -125,9 +124,7 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newSingleThreadExecutor(null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -137,6 +134,7 @@ public class ExecutorsTest extends JSR16 ExecutorService e = Executors.newSingleThreadExecutor(); try { ThreadPoolExecutor tpe = (ThreadPoolExecutor)e; + shouldThrow(); } catch (ClassCastException success) { } finally { joinPool(e); @@ -173,9 +171,7 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newFixedThreadPool(2, null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -185,9 +181,7 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newFixedThreadPool(0); shouldThrow(); - } - catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } @@ -208,9 +202,8 @@ public class ExecutorsTest extends JSR16 public void testunconfigurableExecutorServiceNPE() { try { ExecutorService e = Executors.unconfigurableExecutorService(null); - } - catch (NullPointerException success) { - } + shouldThrow(); + } catch (NullPointerException success) {} } /** @@ -219,88 +212,69 @@ 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() { + public void testTimedCallable() throws Exception { int N = 10000; ExecutorService executor = Executors.newSingleThreadExecutor(); List> tasks = new ArrayList>(N); try { long startTime = System.currentTimeMillis(); - + long i = 0; while (tasks.size() < N) { tasks.add(new TimedCallable(executor, new Fib(i), 1)); i += 10; } - + int iters = 0; BigInteger sum = BigInteger.ZERO; for (Iterator> it = tasks.iterator(); it.hasNext();) { @@ -312,9 +286,6 @@ public class ExecutorsTest extends JSR16 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; @@ -325,44 +296,42 @@ 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 - } + 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()); - + e.execute(r); try { e.shutdown(); - } catch(SecurityException ok) { + } catch (SecurityException ok) { } - + try { Thread.sleep(SHORT_DELAY_MS); - } catch (Exception eX) { - unexpectedException(); } finally { joinPool(e); } @@ -373,7 +342,7 @@ public class ExecutorsTest extends JSR16 * specified group, priority, daemon status, name, * access control context and context class loader */ - public void testPrivilegedThreadFactory() { + public void testPrivilegedThreadFactory() throws Exception { Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); @@ -389,47 +358,52 @@ public class ExecutorsTest extends JSR16 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 - } + 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) { + } catch (SecurityException ok) { } try { Thread.sleep(SHORT_DELAY_MS); - } catch (Exception ex) { - unexpectedException(); } finally { joinPool(e); } } - static class CheckCCL implements Callable { + void checkCCL() { + SecurityManager sm = System.getSecurityManager(); + if (sm != null) { + sm.checkPermission(new RuntimePermission("setContextClassLoader")); + sm.checkPermission(new RuntimePermission("getClassLoader")); + } + } + + class CheckCCL implements Callable { public Object call() { - AccessControlContext acc = AccessController.getContext(); - acc.checkPermission(new RuntimePermission("getContextClassLoader")); + checkCCL(); return null; } } @@ -440,7 +414,7 @@ public class ExecutorsTest extends JSR16 * privilegedCallableUsingCurrentClassLoader throws ACE */ public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() { - Policy savedPolicy = null; + Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); AdjustablePolicy policy = new AdjustablePolicy(); @@ -449,24 +423,30 @@ public class ExecutorsTest extends JSR16 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 { + } catch (AccessControlException success) { + } finally { Policy.setPolicy(savedPolicy); } } /** - * Without class loader permissions, calling - * privilegedCallableUsingCurrentClassLoader throws ACE + * With class loader permissions, calling + * privilegedCallableUsingCurrentClassLoader does not throw ACE */ - public void testprivilegedCallableUsingCCLWithPrivs() { - Policy savedPolicy = null; + public void testprivilegedCallableUsingCCLWithPrivs() throws Exception { + Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); AdjustablePolicy policy = new AdjustablePolicy(); @@ -476,13 +456,11 @@ public class ExecutorsTest extends JSR16 } catch (AccessControlException ok) { return; } - + try { Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable()); task.call(); - } catch(Exception ex) { - unexpectedException(); - } + } finally { Policy.setPolicy(savedPolicy); } @@ -491,33 +469,45 @@ public class ExecutorsTest extends JSR16 /** * Without permissions, calling privilegedCallable throws ACE */ - public void testprivilegedCallableWithNoPrivs() { - Policy savedPolicy = null; + public void testprivilegedCallableWithNoPrivs() throws Exception { + Callable task; + Policy savedPolicy = null; + AdjustablePolicy policy = null; + AccessControlContext noprivAcc = null; try { savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); + 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) { } - Callable task = Executors.privilegedCallable(new CheckCCL()); - Policy.setPolicy(savedPolicy); try { task.call(); shouldThrow(); - } catch(AccessControlException success) { - } catch(Exception ex) { - unexpectedException(); - } finally { - } + } catch (AccessControlException success) {} } /** * With permissions, calling privilegedCallable succeeds */ - public void testprivilegedCallableWithPrivs() { - Policy savedPolicy = null; + public void testprivilegedCallableWithPrivs() throws Exception { + Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); AdjustablePolicy policy = new AdjustablePolicy(); @@ -527,12 +517,10 @@ public class ExecutorsTest extends JSR16 } catch (AccessControlException ok) { return; } - + Callable task = Executors.privilegedCallable(new CheckCCL()); try { task.call(); - } catch(Exception ex) { - unexpectedException(); } finally { Policy.setPolicy(savedPolicy); } @@ -540,98 +528,77 @@ public class ExecutorsTest extends JSR16 /** * 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); + assertEquals(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; }}); + */ + public void testCallable3() throws Exception { + 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(); - } + */ + public void testCallable4() throws Exception { + Callable c = Executors.callable(new PrivilegedExceptionAction() { + public Object run() { return one; }}); + assertEquals(one, c.call()); } /** * callable(null Runnable) throws NPE - */ + */ 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) {} } /** * callable(null, result) throws NPE - */ + */ 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) {} } /** * callable(null PrivilegedAction) throws NPE - */ + */ 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) {} } /** * callable(null PrivilegedExceptionAction) throws NPE - */ + */ 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) {} }