--- jsr166/src/test/tck/ExecutorsTest.java 2003/12/10 01:51:12 1.10 +++ jsr166/src/test/tck/ExecutorsTest.java 2009/12/02 19:17:01 1.28 @@ -1,65 +1,27 @@ /* - * 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. */ 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 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); - } - } - } - - - 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; - } - return f1; - } - }; - /** * A newCachedThreadPool can execute runnables */ @@ -68,7 +30,7 @@ public class ExecutorsTest extends JSR16 e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); - e.shutdown(); + joinPool(e); } /** @@ -79,7 +41,7 @@ public class ExecutorsTest extends JSR16 e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); - e.shutdown(); + joinPool(e); } /** @@ -89,9 +51,7 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newCachedThreadPool(null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } @@ -103,7 +63,7 @@ public class ExecutorsTest extends JSR16 e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); - e.shutdown(); + joinPool(e); } /** @@ -114,7 +74,7 @@ public class ExecutorsTest extends JSR16 e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); - e.shutdown(); + joinPool(e); } /** @@ -124,11 +84,24 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newSingleThreadExecutor(null); shouldThrow(); - } - catch(NullPointerException success) { + } catch (NullPointerException success) {} + } + + /** + * A new SingleThreadExecutor cannot be casted to concrete implementation + */ + public void testCastNewSingleThreadExecutor() { + ExecutorService e = Executors.newSingleThreadExecutor(); + try { + ThreadPoolExecutor tpe = (ThreadPoolExecutor)e; + shouldThrow(); + } catch (ClassCastException success) { + } finally { + joinPool(e); } } + /** * A new newFixedThreadPool can execute runnables */ @@ -137,7 +110,7 @@ public class ExecutorsTest extends JSR16 e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); - e.shutdown(); + joinPool(e); } /** @@ -148,7 +121,7 @@ public class ExecutorsTest extends JSR16 e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); e.execute(new NoOpRunnable()); - e.shutdown(); + joinPool(e); } /** @@ -158,9 +131,7 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newFixedThreadPool(2, null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -170,82 +141,152 @@ public class ExecutorsTest extends JSR16 try { ExecutorService e = Executors.newFixedThreadPool(0); shouldThrow(); - } - catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** - * timeouts from execute will time out if they compute too long. + * 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 testTimedCallable() { - int N = 10000; - ExecutorService executor = Executors.newSingleThreadExecutor(); - List> tasks = new ArrayList>(N); + public void testunconfigurableExecutorServiceNPE() { 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();) { + ExecutorService e = Executors.unconfigurableExecutorService(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * unconfigurableScheduledExecutorService(null) throws NPE + */ + public void testunconfigurableScheduledExecutorServiceNPE() { + try { + ExecutorService e = Executors.unconfigurableScheduledExecutorService(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * a newSingleThreadScheduledExecutor successfully runs delayed task + */ + 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() 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() 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); + } + + /** + * Future.get on submitted tasks will time out if they compute too long. + */ + public void testTimedCallable() throws Exception { + final Runnable sleeper = + new RunnableShouldThrow(InterruptedException.class) { + 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); + } } } - + /** * 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() { - 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")); + 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); - e.shutdown(); + try { + e.shutdown(); + } catch (SecurityException ok) { + } + try { Thread.sleep(SHORT_DELAY_MS); - } catch (Exception eX) { - unexpectedException(); } finally { joinPool(e); } @@ -256,45 +297,263 @@ public class ExecutorsTest extends JSR16 * 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); + public void testPrivilegedThreadFactory() throws Exception { + 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() { - 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())); + 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); - e.shutdown(); + try { + e.shutdown(); + } catch (SecurityException ok) { + } try { Thread.sleep(SHORT_DELAY_MS); - } catch (Exception ex) { - unexpectedException(); } finally { joinPool(e); } + } + 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() { + checkCCL(); + return null; + } + } + + + /** + * 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) { + } finally { + Policy.setPolicy(savedPolicy); + } + } + + /** + * With class loader permissions, calling + * privilegedCallableUsingCurrentClassLoader does not throw ACE + */ + public void testprivilegedCallableUsingCCLWithPrivs() throws Exception { + 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(); + } + finally { + Policy.setPolicy(savedPolicy); + } + } + + /** + * Without permissions, calling privilegedCallable throws ACE + */ + public void testprivilegedCallableWithNoPrivs() throws Exception { + 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) {} + } + + /** + * With permissions, calling privilegedCallable succeeds + */ + public void testprivilegedCallableWithPrivs() throws Exception { + 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(); + } finally { + Policy.setPolicy(savedPolicy); + } + } + + /** + * callable(Runnable) returns null when called + */ + public void testCallable1() throws Exception { + Callable c = Executors.callable(new NoOpRunnable()); + assertNull(c.call()); + } + + /** + * callable(Runnable, result) returns result when called + */ + 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() 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() throws Exception { + Callable c = Executors.callable(new PrivilegedExceptionAction() { + public Object run() { return one; }}); + assertSame(one, c.call()); + } + + + /** + * callable(null Runnable) throws NPE + */ + public void testCallableNPE1() { + try { + Callable c = Executors.callable((Runnable) null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * callable(null, result) throws NPE + */ + public void testCallableNPE2() { + try { + Callable c = Executors.callable((Runnable) null, one); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * callable(null PrivilegedAction) throws NPE + */ + public void testCallableNPE3() { + try { + Callable c = Executors.callable((PrivilegedAction) null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * callable(null PrivilegedExceptionAction) throws NPE + */ + public void testCallableNPE4() { + try { + Callable c = Executors.callable((PrivilegedExceptionAction) null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + }