--- jsr166/src/test/tck/CompletableFutureTest.java 2014/06/18 02:37:38 1.94 +++ jsr166/src/test/tck/CompletableFutureTest.java 2015/01/15 18:34:19 1.100 @@ -5,30 +5,31 @@ * http://creativecommons.org/publicdomain/zero/1.0/ */ -import junit.framework.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.concurrent.TimeUnit.SECONDS; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; import java.util.concurrent.Callable; -import java.util.concurrent.Executor; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; import java.util.concurrent.CancellationException; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; import java.util.concurrent.CompletionStage; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executor; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; 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 java.util.function.Supplier; -import java.util.function.Consumer; import java.util.function.BiConsumer; -import java.util.function.Function; import java.util.function.BiFunction; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; + +import junit.framework.Test; +import junit.framework.TestSuite; public class CompletableFutureTest extends JSR166TestCase { @@ -57,9 +58,8 @@ public class CompletableFutureTest exten } void checkCompletedNormally(CompletableFuture f, T value) { - try { - assertEquals(value, f.get(LONG_DELAY_MS, MILLISECONDS)); - } catch (Throwable fail) { threadUnexpectedException(fail); } + checkTimedGet(f, value); + try { assertEquals(value, f.join()); } catch (Throwable fail) { threadUnexpectedException(fail); } @@ -76,12 +76,16 @@ public class CompletableFutureTest exten } void checkCompletedWithWrappedCFException(CompletableFuture f) { + long startTime = System.nanoTime(); + long timeoutMillis = LONG_DELAY_MS; try { - f.get(LONG_DELAY_MS, MILLISECONDS); + f.get(timeoutMillis, MILLISECONDS); shouldThrow(); } catch (ExecutionException success) { assertTrue(success.getCause() instanceof CFException); } catch (Throwable fail) { threadUnexpectedException(fail); } + assertTrue(millisElapsedSince(startTime) < timeoutMillis/2); + try { f.join(); shouldThrow(); @@ -107,12 +111,16 @@ public class CompletableFutureTest exten void checkCompletedExceptionallyWithRootCause(CompletableFuture f, Throwable ex) { + long startTime = System.nanoTime(); + long timeoutMillis = LONG_DELAY_MS; try { - f.get(LONG_DELAY_MS, MILLISECONDS); + f.get(timeoutMillis, MILLISECONDS); shouldThrow(); } catch (ExecutionException success) { assertSame(ex, success.getCause()); } catch (Throwable fail) { threadUnexpectedException(fail); } + assertTrue(millisElapsedSince(startTime) < timeoutMillis/2); + try { f.join(); shouldThrow(); @@ -158,11 +166,15 @@ public class CompletableFutureTest exten } void checkCancelled(CompletableFuture f) { + long startTime = System.nanoTime(); + long timeoutMillis = LONG_DELAY_MS; try { - f.get(LONG_DELAY_MS, MILLISECONDS); + f.get(timeoutMillis, MILLISECONDS); shouldThrow(); } catch (CancellationException success) { } catch (Throwable fail) { threadUnexpectedException(fail); } + assertTrue(millisElapsedSince(startTime) < timeoutMillis/2); + try { f.join(); shouldThrow(); @@ -183,12 +195,16 @@ public class CompletableFutureTest exten } void checkCompletedWithWrappedCancellationException(CompletableFuture f) { + long startTime = System.nanoTime(); + long timeoutMillis = LONG_DELAY_MS; try { - f.get(LONG_DELAY_MS, MILLISECONDS); + f.get(timeoutMillis, MILLISECONDS); shouldThrow(); } catch (ExecutionException success) { assertTrue(success.getCause() instanceof CancellationException); } catch (Throwable fail) { threadUnexpectedException(fail); } + assertTrue(millisElapsedSince(startTime) < timeoutMillis/2); + try { f.join(); shouldThrow(); @@ -530,7 +546,6 @@ public class CompletableFutureTest exten } } - class CompletableFutureInc extends CheckedIntegerAction implements Function> { @@ -569,12 +584,15 @@ public class CompletableFutureTest exten } } + static final boolean defaultExecutorIsCommonPool + = ForkJoinPool.getCommonPoolParallelism() > 1; + /** * Permits the testing of parallel code for the 3 different * execution modes without copy/pasting all the test methods. */ enum ExecutionMode { - DEFAULT { + SYNC { public void checkExecutionMode() { assertFalse(ThreadExecutor.startedCurrentThread()); assertNull(ForkJoinTask.getPool()); @@ -650,8 +668,8 @@ public class CompletableFutureTest exten ASYNC { public void checkExecutionMode() { - assertSame(ForkJoinPool.commonPool(), - ForkJoinTask.getPool()); + assertEquals(defaultExecutorIsCommonPool, + (ForkJoinPool.commonPool() == ForkJoinTask.getPool())); } public CompletableFuture runAsync(Runnable a) { return CompletableFuture.runAsync(a); @@ -875,7 +893,7 @@ public class CompletableFutureTest exten if (!createIncomplete) f.completeExceptionally(ex); final CompletableFuture g = f.exceptionally ((Throwable t) -> { - ExecutionMode.DEFAULT.checkExecutionMode(); + ExecutionMode.SYNC.checkExecutionMode(); threadAssertSame(t, ex); a.getAndIncrement(); return v1; @@ -897,7 +915,7 @@ public class CompletableFutureTest exten if (!createIncomplete) f.completeExceptionally(ex1); final CompletableFuture g = f.exceptionally ((Throwable t) -> { - ExecutionMode.DEFAULT.checkExecutionMode(); + ExecutionMode.SYNC.checkExecutionMode(); threadAssertSame(t, ex1); a.getAndIncrement(); throw ex2; @@ -2975,6 +2993,58 @@ public class CompletableFutureTest exten checkCancelled(f); }} + /** + * thenCompose result completes exceptionally if the result of the action does + */ + public void testThenCompose_actionReturnsFailingFuture() { + for (ExecutionMode m : ExecutionMode.values()) + for (int order = 0; order < 6; order++) + for (Integer v1 : new Integer[] { 1, null }) + { + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CompletableFuture h; + // Test all permutations of orders + switch (order) { + case 0: + assertTrue(f.complete(v1)); + assertTrue(g.completeExceptionally(ex)); + h = m.thenCompose(f, (x -> g)); + break; + case 1: + assertTrue(f.complete(v1)); + h = m.thenCompose(f, (x -> g)); + assertTrue(g.completeExceptionally(ex)); + break; + case 2: + assertTrue(g.completeExceptionally(ex)); + assertTrue(f.complete(v1)); + h = m.thenCompose(f, (x -> g)); + break; + case 3: + assertTrue(g.completeExceptionally(ex)); + h = m.thenCompose(f, (x -> g)); + assertTrue(f.complete(v1)); + break; + case 4: + h = m.thenCompose(f, (x -> g)); + assertTrue(f.complete(v1)); + assertTrue(g.completeExceptionally(ex)); + break; + case 5: + h = m.thenCompose(f, (x -> g)); + assertTrue(f.complete(v1)); + assertTrue(g.completeExceptionally(ex)); + break; + default: throw new AssertionError(); + } + + checkCompletedExceptionally(g, ex); + checkCompletedWithWrappedException(h, ex); + checkCompletedNormally(f, v1); + }} + // other static methods /** @@ -3148,7 +3218,7 @@ public class CompletableFutureTest exten Runnable[] throwingActions = { () -> CompletableFuture.supplyAsync(null), () -> CompletableFuture.supplyAsync(null, exec), - () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null), + () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.SYNC, 42), null), () -> CompletableFuture.runAsync(null), () -> CompletableFuture.runAsync(null, exec),