--- jsr166/src/test/tck/FutureTaskTest.java 2012/12/15 21:48:32 1.30 +++ jsr166/src/test/tck/FutureTaskTest.java 2015/04/25 04:55:30 1.43 @@ -6,23 +6,31 @@ * Pat Fisher, Mike Judd. */ -import junit.framework.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static java.util.concurrent.TimeUnit.SECONDS; + +import java.util.ArrayList; +import java.util.List; +import java.util.NoSuchElementException; import java.util.concurrent.Callable; import java.util.concurrent.CancellationException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executors; +import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicInteger; -import static java.util.concurrent.TimeUnit.MILLISECONDS; -import static java.util.concurrent.TimeUnit.SECONDS; -import java.util.*; + +import junit.framework.Test; +import junit.framework.TestSuite; public class FutureTaskTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run(suite()); + main(suite(), args); } public static Test suite() { return new TestSuite(FutureTaskTest.class); @@ -37,16 +45,31 @@ public class FutureTaskTest extends JSR1 assertEquals(1, pf.doneCount()); assertFalse(pf.runAndReset()); assertEquals(1, pf.doneCount()); + Object r = null; Object exInfo = null; + try { + r = f.get(); + } catch (CancellationException t) { + exInfo = CancellationException.class; + } catch (ExecutionException t) { + exInfo = t.getCause(); + } catch (Throwable t) { + threadUnexpectedException(t); + } // Check that run and runAndReset have no effect. int savedRunCount = pf.runCount(); - int savedSetCount = pf.setCount(); - int savedSetExceptionCount = pf.setExceptionCount(); pf.run(); pf.runAndReset(); assertEquals(savedRunCount, pf.runCount()); - assertEquals(savedSetCount, pf.setCount()); - assertEquals(savedSetExceptionCount, pf.setExceptionCount()); + try { + assertSame(r, f.get()); + } catch (CancellationException t) { + assertSame(exInfo, CancellationException.class); + } catch (ExecutionException t) { + assertSame(exInfo, t.getCause()); + } catch (Throwable t) { + threadUnexpectedException(t); + } assertTrue(f.isDone()); } } @@ -68,8 +91,13 @@ public class FutureTaskTest extends JSR1 FutureTask ft = (FutureTask) f; // Check that run methods do nothing ft.run(); - if (f instanceof PublicFutureTask) - assertFalse(((PublicFutureTask) f).runAndReset()); + if (f instanceof PublicFutureTask) { + PublicFutureTask pf = (PublicFutureTask) f; + int savedRunCount = pf.runCount(); + pf.run(); + assertFalse(pf.runAndReset()); + assertEquals(savedRunCount, pf.runCount()); + } checkNotDone(f); } } @@ -107,7 +135,7 @@ public class FutureTaskTest extends JSR1 pf.set(new Object()); pf.setException(new Error()); for (boolean mayInterruptIfRunning : new boolean[] { true, false }) { - pf.cancel(true); + pf.cancel(mayInterruptIfRunning); } } @@ -154,10 +182,10 @@ public class FutureTaskTest extends JSR1 private PublicFutureTask(final Runnable runnable, Object result, final AtomicInteger runCount) { super(new Runnable() { - public void run() { - runCount.getAndIncrement(); - runnable.run(); - }}, result); + public void run() { + runCount.getAndIncrement(); + runnable.run(); + }}, result); this.runCount = runCount; } PublicFutureTask(Callable callable) { @@ -319,11 +347,14 @@ public class FutureTaskTest extends JSR1 PublicFutureTask task = new PublicFutureTask(new NoOpCallable()); assertTrue(task.cancel(false)); task.run(); + assertEquals(0, task.runCount()); assertEquals(0, task.setCount()); assertEquals(0, task.setExceptionCount()); + assertTrue(task.isCancelled()); + assertTrue(task.isDone()); tryToConfuseDoneTask(task); - checkCancelled(task); assertEquals(0, task.runCount()); + checkCancelled(task); } /** @@ -333,11 +364,14 @@ public class FutureTaskTest extends JSR1 PublicFutureTask task = new PublicFutureTask(new NoOpCallable()); assertTrue(task.cancel(true)); task.run(); + assertEquals(0, task.runCount()); assertEquals(0, task.setCount()); assertEquals(0, task.setExceptionCount()); + assertTrue(task.isCancelled()); + assertTrue(task.isDone()); tryToConfuseDoneTask(task); - checkCancelled(task); assertEquals(0, task.runCount()); + checkCancelled(task); } /** @@ -347,6 +381,7 @@ public class FutureTaskTest extends JSR1 PublicFutureTask task = new PublicFutureTask(new NoOpCallable()); task.run(); assertFalse(task.cancel(false)); + assertEquals(1, task.runCount()); assertEquals(1, task.setCount()); assertEquals(0, task.setExceptionCount()); tryToConfuseDoneTask(task); @@ -361,6 +396,7 @@ public class FutureTaskTest extends JSR1 PublicFutureTask task = new PublicFutureTask(new NoOpCallable()); task.run(); assertFalse(task.cancel(true)); + assertEquals(1, task.runCount()); assertEquals(1, task.setCount()); assertEquals(0, task.setExceptionCount()); tryToConfuseDoneTask(task); @@ -387,6 +423,7 @@ public class FutureTaskTest extends JSR1 await(pleaseCancel); assertTrue(task.cancel(true)); assertTrue(task.isCancelled()); + assertTrue(task.isDone()); awaitTermination(t); assertEquals(1, task.runCount()); assertEquals(1, task.setCount()); @@ -396,6 +433,52 @@ public class FutureTaskTest extends JSR1 } /** + * cancel(true) tries to interrupt a running task, but + * Thread.interrupt throws (simulating a restrictive security + * manager) + */ + public void testCancelInterrupt_ThrowsSecurityException() { + final CountDownLatch pleaseCancel = new CountDownLatch(1); + final CountDownLatch cancelled = new CountDownLatch(1); + final PublicFutureTask task = + new PublicFutureTask(new CheckedRunnable() { + public void realRun() { + pleaseCancel.countDown(); + await(cancelled); + assertFalse(Thread.interrupted()); + }}); + + final Thread t = new Thread(task) { + // Simulate a restrictive security manager. + @Override public void interrupt() { + throw new SecurityException(); + }}; + t.setDaemon(true); + t.start(); + + await(pleaseCancel); + try { + task.cancel(true); + shouldThrow(); + } catch (SecurityException expected) {} + + // We failed to deliver the interrupt, but the world retains + // its sanity, as if we had done task.cancel(false) + assertTrue(task.isCancelled()); + assertTrue(task.isDone()); + assertEquals(1, task.runCount()); + assertEquals(1, task.doneCount()); + assertEquals(0, task.setCount()); + assertEquals(0, task.setExceptionCount()); + cancelled.countDown(); + awaitTermination(t); + assertEquals(1, task.setCount()); + assertEquals(0, task.setExceptionCount()); + tryToConfuseDoneTask(task); + checkCancelled(task); + } + + /** * cancel(true) interrupts a running task that subsequently throws */ public void testCancelInterrupt_taskFails() { @@ -403,10 +486,13 @@ public class FutureTaskTest extends JSR1 final PublicFutureTask task = new PublicFutureTask(new Runnable() { public void run() { + pleaseCancel.countDown(); try { - pleaseCancel.countDown(); delay(LONG_DELAY_MS); - } finally { throw new RuntimeException(); } + threadShouldThrow(); + } catch (InterruptedException success) { + } catch (Throwable t) { threadUnexpectedException(t); } + throw new RuntimeException(); }}); Thread t = newStartedThread(task); @@ -531,51 +617,55 @@ public class FutureTaskTest extends JSR1 * CancellationException */ public void testTimedGet_Cancellation() { - for (final boolean mayInterruptIfRunning : - new boolean[] { true, false }) { - final CountDownLatch pleaseCancel = new CountDownLatch(3); - final CountDownLatch cancelled = new CountDownLatch(1); - final PublicFutureTask task = - new PublicFutureTask(new CheckedCallable() { - public Object realCall() throws InterruptedException { - pleaseCancel.countDown(); - if (mayInterruptIfRunning) { - try { - delay(2*LONG_DELAY_MS); - } catch (InterruptedException success) {} - } else { - await(cancelled); - } - return two; - }}); + testTimedGet_Cancellation(false); + } + public void testTimedGet_Cancellation_interrupt() { + testTimedGet_Cancellation(true); + } + public void testTimedGet_Cancellation(final boolean mayInterruptIfRunning) { + final CountDownLatch pleaseCancel = new CountDownLatch(3); + final CountDownLatch cancelled = new CountDownLatch(1); + final Callable callable = + new CheckedCallable() { + public Object realCall() throws InterruptedException { + pleaseCancel.countDown(); + if (mayInterruptIfRunning) { + try { + delay(2*LONG_DELAY_MS); + } catch (InterruptedException success) {} + } else { + await(cancelled); + } + return two; + }}; + final PublicFutureTask task = new PublicFutureTask(callable); - Thread t1 = new ThreadShouldThrow(CancellationException.class) { + Thread t1 = new ThreadShouldThrow(CancellationException.class) { public void realRun() throws Exception { pleaseCancel.countDown(); task.get(); }}; - Thread t2 = new ThreadShouldThrow(CancellationException.class) { + Thread t2 = new ThreadShouldThrow(CancellationException.class) { public void realRun() throws Exception { pleaseCancel.countDown(); task.get(2*LONG_DELAY_MS, MILLISECONDS); }}; - t1.start(); - t2.start(); - Thread t3 = newStartedThread(task); - await(pleaseCancel); - checkIsRunning(task); - task.cancel(mayInterruptIfRunning); - checkCancelled(task); - awaitTermination(t1); - awaitTermination(t2); - cancelled.countDown(); - awaitTermination(t3); - assertEquals(1, task.runCount()); - assertEquals(1, task.setCount()); - assertEquals(0, task.setExceptionCount()); - tryToConfuseDoneTask(task); - checkCancelled(task); - } + t1.start(); + t2.start(); + Thread t3 = newStartedThread(task); + await(pleaseCancel); + checkIsRunning(task); + task.cancel(mayInterruptIfRunning); + checkCancelled(task); + awaitTermination(t1); + awaitTermination(t2); + cancelled.countDown(); + awaitTermination(t3); + assertEquals(1, task.runCount()); + assertEquals(1, task.setCount()); + assertEquals(0, task.setExceptionCount()); + tryToConfuseDoneTask(task); + checkCancelled(task); } /** @@ -719,4 +809,31 @@ public class FutureTaskTest extends JSR1 } } + /** + * timed get with most negative timeout works correctly (i.e. no + * underflow bug) + */ + public void testGet_NegativeInfinityTimeout() throws Exception { + final ExecutorService pool = Executors.newFixedThreadPool(10); + final Runnable nop = new Runnable() { public void run() {}}; + final FutureTask task = new FutureTask<>(nop, null); + final List> futures = new ArrayList<>(); + Runnable r = new Runnable() { public void run() { + for (long timeout : new long[] { 0L, -1L, Long.MIN_VALUE }) { + try { + task.get(timeout, NANOSECONDS); + shouldThrow(); + } catch (TimeoutException success) { + } catch (Throwable fail) {threadUnexpectedException(fail);}}}}; + for (int i = 0; i < 10; i++) + futures.add(pool.submit(r)); + try { + joinPool(pool); + for (Future future : futures) + checkCompletedNormally(future, null); + } finally { + task.run(); // last resort to help terminate + } + } + }