--- jsr166/src/test/tck/ExecutorsTest.java 2011/05/27 19:28:38 1.40 +++ jsr166/src/test/tck/ExecutorsTest.java 2020/02/01 18:52:17 1.54 @@ -6,16 +6,29 @@ * 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.*; + +import java.security.AccessControlContext; +import java.security.AccessControlException; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.security.PrivilegedExceptionAction; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.Callable; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Executors; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Future; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ThreadPoolExecutor; + +import junit.framework.Test; +import junit.framework.TestSuite; public class ExecutorsTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run(suite()); + main(suite(), args); } public static Test suite() { return new TestSuite(ExecutorsTest.class); @@ -25,22 +38,24 @@ public class ExecutorsTest extends JSR16 * 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); + final ExecutorService e = Executors.newCachedThreadPool(); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** * 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); + final ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory()); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** @@ -48,7 +63,7 @@ public class ExecutorsTest extends JSR16 */ public void testNewCachedThreadPool3() { try { - ExecutorService e = Executors.newCachedThreadPool(null); + ExecutorService unused = Executors.newCachedThreadPool(null); shouldThrow(); } catch (NullPointerException success) {} } @@ -57,22 +72,24 @@ public class ExecutorsTest extends JSR16 * 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()); - joinPool(e); + final ExecutorService e = Executors.newSingleThreadExecutor(); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** * 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); + final ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory()); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** @@ -80,7 +97,7 @@ public class ExecutorsTest extends JSR16 */ public void testNewSingleThreadExecutor3() { try { - ExecutorService e = Executors.newSingleThreadExecutor(null); + ExecutorService unused = Executors.newSingleThreadExecutor(null); shouldThrow(); } catch (NullPointerException success) {} } @@ -89,13 +106,12 @@ public class ExecutorsTest extends JSR16 * 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); + final ExecutorService e = Executors.newSingleThreadExecutor(); + try (PoolCleaner cleaner = cleaner(e)) { + try { + ThreadPoolExecutor tpe = (ThreadPoolExecutor)e; + shouldThrow(); + } catch (ClassCastException success) {} } } @@ -103,40 +119,43 @@ public class ExecutorsTest extends JSR16 * 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); + final ExecutorService e = Executors.newFixedThreadPool(2); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** * 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); + final ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory()); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** - * A new newFixedThreadPool with null ThreadFactory throws NPE + * A new newFixedThreadPool with null ThreadFactory throws + * NullPointerException */ public void testNewFixedThreadPool3() { try { - ExecutorService e = Executors.newFixedThreadPool(2, null); + ExecutorService unused = Executors.newFixedThreadPool(2, null); shouldThrow(); } catch (NullPointerException success) {} } /** - * A new newFixedThreadPool with 0 threads throws IAE + * A new newFixedThreadPool with 0 threads throws IllegalArgumentException */ public void testNewFixedThreadPool4() { try { - ExecutorService e = Executors.newFixedThreadPool(0); + ExecutorService unused = Executors.newFixedThreadPool(0); shouldThrow(); } catch (IllegalArgumentException success) {} } @@ -144,20 +163,22 @@ public class ExecutorsTest extends JSR16 /** * 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); + public void testUnconfigurableExecutorService() { + final ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2)); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + e.execute(new NoOpRunnable()); + } } /** * unconfigurableExecutorService(null) throws NPE */ - public void testunconfigurableExecutorServiceNPE() { + public void testUnconfigurableExecutorServiceNPE() { try { - ExecutorService e = Executors.unconfigurableExecutorService(null); + ExecutorService unused = + Executors.unconfigurableExecutorService(null); shouldThrow(); } catch (NullPointerException success) {} } @@ -165,9 +186,10 @@ public class ExecutorsTest extends JSR16 /** * unconfigurableScheduledExecutorService(null) throws NPE */ - public void testunconfigurableScheduledExecutorServiceNPE() { + public void testUnconfigurableScheduledExecutorServiceNPE() { try { - ExecutorService e = Executors.unconfigurableScheduledExecutorService(null); + ExecutorService unused = + Executors.unconfigurableScheduledExecutorService(null); shouldThrow(); } catch (NullPointerException success) {} } @@ -176,70 +198,73 @@ public class ExecutorsTest extends JSR16 * a newSingleThreadScheduledExecutor successfully runs delayed task */ public void testNewSingleThreadScheduledExecutor() throws Exception { - ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor(); - try { - final CountDownLatch done = new CountDownLatch(1); + final ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor(); + try (PoolCleaner cleaner = cleaner(p)) { + final CountDownLatch proceed = new CountDownLatch(1); final Runnable task = new CheckedRunnable() { public void realRun() { - done.countDown(); + await(proceed); }}; + long startTime = System.nanoTime(); Future f = p.schedule(Executors.callable(task, Boolean.TRUE), - SHORT_DELAY_MS, MILLISECONDS); + timeoutMillis(), MILLISECONDS); assertFalse(f.isDone()); - assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS)); - assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS)); + proceed.countDown(); + assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS)); assertSame(Boolean.TRUE, f.get()); assertTrue(f.isDone()); - } finally { - joinPool(p); + assertFalse(f.isCancelled()); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); } } /** * a newScheduledThreadPool successfully runs delayed task */ - public void testnewScheduledThreadPool() throws Exception { - ScheduledExecutorService p = Executors.newScheduledThreadPool(2); - try { - final CountDownLatch done = new CountDownLatch(1); + public void testNewScheduledThreadPool() throws Exception { + final ScheduledExecutorService p = Executors.newScheduledThreadPool(2); + try (PoolCleaner cleaner = cleaner(p)) { + final CountDownLatch proceed = new CountDownLatch(1); final Runnable task = new CheckedRunnable() { public void realRun() { - done.countDown(); + await(proceed); }}; + long startTime = System.nanoTime(); Future f = p.schedule(Executors.callable(task, Boolean.TRUE), - SHORT_DELAY_MS, MILLISECONDS); + timeoutMillis(), MILLISECONDS); assertFalse(f.isDone()); - assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS)); - assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS)); + proceed.countDown(); + assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS)); assertSame(Boolean.TRUE, f.get()); assertTrue(f.isDone()); - } finally { - joinPool(p); + assertFalse(f.isCancelled()); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); } } /** * an unconfigurable newScheduledThreadPool successfully runs delayed task */ - public void testunconfigurableScheduledExecutorService() throws Exception { - ScheduledExecutorService p = + public void testUnconfigurableScheduledExecutorService() throws Exception { + final ScheduledExecutorService p = Executors.unconfigurableScheduledExecutorService (Executors.newScheduledThreadPool(2)); - try { - final CountDownLatch done = new CountDownLatch(1); + try (PoolCleaner cleaner = cleaner(p)) { + final CountDownLatch proceed = new CountDownLatch(1); final Runnable task = new CheckedRunnable() { public void realRun() { - done.countDown(); + await(proceed); }}; + long startTime = System.nanoTime(); Future f = p.schedule(Executors.callable(task, Boolean.TRUE), - SHORT_DELAY_MS, MILLISECONDS); + timeoutMillis(), MILLISECONDS); assertFalse(f.isDone()); - assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS)); - assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS)); + proceed.countDown(); + assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS)); assertSame(Boolean.TRUE, f.get()); assertTrue(f.isDone()); - } finally { - joinPool(p); + assertFalse(f.isCancelled()); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); } } @@ -254,22 +279,24 @@ public class ExecutorsTest extends JSR16 Executors.newScheduledThreadPool(2), }; - final Runnable sleeper = new CheckedInterruptedRunnable() { + final CountDownLatch done = new CountDownLatch(1); + + final Runnable sleeper = new CheckedRunnable() { public void realRun() throws InterruptedException { - delay(LONG_DELAY_MS); + done.await(LONG_DELAY_MS, MILLISECONDS); }}; - List threads = new ArrayList(); + List threads = new ArrayList<>(); for (final ExecutorService executor : executors) { threads.add(newStartedThread(new CheckedRunnable() { public void realRun() { - long startTime = System.nanoTime(); Future future = executor.submit(sleeper); assertFutureTimesOut(future); }})); } for (Thread thread : threads) awaitTermination(thread); + done.countDown(); for (ExecutorService executor : executors) joinPool(executor); } @@ -280,36 +307,26 @@ public class ExecutorsTest extends JSR16 */ public void testDefaultThreadFactory() throws Exception { final ThreadGroup egroup = Thread.currentThread().getThreadGroup(); + final CountDownLatch done = new CountDownLatch(1); Runnable r = new CheckedRunnable() { public void realRun() { try { Thread current = Thread.currentThread(); - assertTrue(!current.isDaemon()); + assertFalse(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(current.getThreadGroup(), + (s == null) ? egroup : s.getThreadGroup()); + assertTrue(current.getName().endsWith("thread-1")); } catch (SecurityException ok) { // Also pass if not allowed to change setting } + done.countDown(); }}; ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory()); - - e.execute(r); - try { - e.shutdown(); - } catch (SecurityException ok) { - } - - try { - delay(SHORT_DELAY_MS); - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(r); + await(done); } } @@ -319,6 +336,7 @@ public class ExecutorsTest extends JSR16 * access control context and context class loader */ public void testPrivilegedThreadFactory() throws Exception { + final CountDownLatch done = new CountDownLatch(1); Runnable r = new CheckedRunnable() { public void realRun() throws Exception { final ThreadGroup egroup = Thread.currentThread().getThreadGroup(); @@ -327,24 +345,21 @@ public class ExecutorsTest extends JSR16 Runnable r = new CheckedRunnable() { public void realRun() { Thread current = Thread.currentThread(); - assertTrue(!current.isDaemon()); + assertFalse(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(current.getThreadGroup(), + (s == null) ? egroup : s.getThreadGroup()); + assertTrue(current.getName().endsWith("thread-1")); assertSame(thisccl, current.getContextClassLoader()); assertEquals(thisacc, AccessController.getContext()); + done.countDown(); }}; ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory()); - e.execute(r); - e.shutdown(); - delay(SHORT_DELAY_MS); - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + e.execute(r); + await(done); + } }}; runWithPermissions(r, @@ -403,7 +418,7 @@ public class ExecutorsTest extends JSR16 * With class loader permissions, calling * privilegedCallableUsingCurrentClassLoader does not throw ACE */ - public void testprivilegedCallableUsingCCLWithPrivs() throws Exception { + public void testPrivilegedCallableUsingCCLWithPrivs() throws Exception { Runnable r = new CheckedRunnable() { public void realRun() throws Exception { Executors.privilegedCallableUsingCurrentClassLoader @@ -419,7 +434,7 @@ public class ExecutorsTest extends JSR16 /** * Without permissions, calling privilegedCallable throws ACE */ - public void testprivilegedCallableWithNoPrivs() throws Exception { + public void testPrivilegedCallableWithNoPrivs() throws Exception { // Avoid classloader-related SecurityExceptions in swingui.TestRunner Executors.privilegedCallable(new CheckCCL()); @@ -491,7 +506,7 @@ public class ExecutorsTest extends JSR16 /** * With permissions, calling privilegedCallable succeeds */ - public void testprivilegedCallableWithPrivs() throws Exception { + public void testPrivilegedCallableWithPrivs() throws Exception { Runnable r = new CheckedRunnable() { public void realRun() throws Exception { Executors.privilegedCallable(new CheckCCL()).call(); @@ -541,7 +556,7 @@ public class ExecutorsTest extends JSR16 */ public void testCallableNPE1() { try { - Callable c = Executors.callable((Runnable) null); + Callable unused = Executors.callable((Runnable) null); shouldThrow(); } catch (NullPointerException success) {} } @@ -551,7 +566,7 @@ public class ExecutorsTest extends JSR16 */ public void testCallableNPE2() { try { - Callable c = Executors.callable((Runnable) null, one); + Callable unused = Executors.callable((Runnable) null, one); shouldThrow(); } catch (NullPointerException success) {} } @@ -561,7 +576,7 @@ public class ExecutorsTest extends JSR16 */ public void testCallableNPE3() { try { - Callable c = Executors.callable((PrivilegedAction) null); + Callable unused = Executors.callable((PrivilegedAction) null); shouldThrow(); } catch (NullPointerException success) {} } @@ -571,9 +586,61 @@ public class ExecutorsTest extends JSR16 */ public void testCallableNPE4() { try { - Callable c = Executors.callable((PrivilegedExceptionAction) null); + Callable unused = Executors.callable((PrivilegedExceptionAction) null); shouldThrow(); } catch (NullPointerException success) {} } + /** + * callable(runnable, x).toString() contains toString of wrapped task + */ + public void testCallable_withResult_toString() { + if (testImplementationDetails) { + Runnable r = () -> {}; + Callable c = Executors.callable(r, ""); + assertEquals( + identityString(c) + "[Wrapped task = " + r.toString() + "]", + c.toString()); + } + } + + /** + * callable(runnable).toString() contains toString of wrapped task + */ + public void testCallable_toString() { + if (testImplementationDetails) { + Runnable r = () -> {}; + Callable c = Executors.callable(r); + assertEquals( + identityString(c) + "[Wrapped task = " + r.toString() + "]", + c.toString()); + } + } + + /** + * privilegedCallable(callable).toString() contains toString of wrapped task + */ + public void testPrivilegedCallable_toString() { + if (testImplementationDetails) { + Callable c = () -> ""; + Callable priv = Executors.privilegedCallable(c); + assertEquals( + identityString(priv) + "[Wrapped task = " + c.toString() + "]", + priv.toString()); + } + } + + /** + * privilegedCallableUsingCurrentClassLoader(callable).toString() + * contains toString of wrapped task + */ + public void testPrivilegedCallableUsingCurrentClassLoader_toString() { + if (testImplementationDetails) { + Callable c = () -> ""; + Callable priv = Executors.privilegedCallableUsingCurrentClassLoader(c); + assertEquals( + identityString(priv) + "[Wrapped task = " + c.toString() + "]", + priv.toString()); + } + } }