--- jsr166/src/test/tck/CompletableFutureTest.java 2014/06/17 20:50:01 1.92 +++ 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; @@ -1600,31 +1618,35 @@ public class CompletableFutureTest exten { final CompletableFuture f = new CompletableFuture<>(); final CompletableFuture g = new CompletableFuture<>(); - final SubtractFunction r1 = new SubtractFunction(m); - final SubtractFunction r2 = new SubtractFunction(m); - final SubtractFunction r3 = new SubtractFunction(m); + final SubtractFunction[] rs = new SubtractFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new SubtractFunction(m); final CompletableFuture fst = fFirst ? f : g; final CompletableFuture snd = !fFirst ? f : g; final Integer w1 = fFirst ? v1 : v2; final Integer w2 = !fFirst ? v1 : v2; - final CompletableFuture h1 = m.thenCombine(f, g, r1); + final CompletableFuture h0 = m.thenCombine(f, g, rs[0]); + final CompletableFuture h1 = m.thenCombine(fst, fst, rs[1]); assertTrue(fst.complete(w1)); - final CompletableFuture h2 = m.thenCombine(f, g, r2); - checkIncomplete(h1); - checkIncomplete(h2); - r1.assertNotInvoked(); - r2.assertNotInvoked(); + final CompletableFuture h2 = m.thenCombine(f, g, rs[2]); + final CompletableFuture h3 = m.thenCombine(fst, fst, rs[3]); + checkIncomplete(h0); rs[0].assertNotInvoked(); + checkIncomplete(h2); rs[2].assertNotInvoked(); + checkCompletedNormally(h1, subtract(w1, w1)); + checkCompletedNormally(h3, subtract(w1, w1)); + rs[1].assertValue(subtract(w1, w1)); + rs[3].assertValue(subtract(w1, w1)); assertTrue(snd.complete(w2)); - final CompletableFuture h3 = m.thenCombine(f, g, r3); + final CompletableFuture h4 = m.thenCombine(f, g, rs[4]); - checkCompletedNormally(h1, subtract(v1, v2)); + checkCompletedNormally(h0, subtract(v1, v2)); checkCompletedNormally(h2, subtract(v1, v2)); - checkCompletedNormally(h3, subtract(v1, v2)); - r1.assertValue(subtract(v1, v2)); - r2.assertValue(subtract(v1, v2)); - r3.assertValue(subtract(v1, v2)); + checkCompletedNormally(h4, subtract(v1, v2)); + rs[0].assertValue(subtract(v1, v2)); + rs[2].assertValue(subtract(v1, v2)); + rs[4].assertValue(subtract(v1, v2)); + checkCompletedNormally(f, v1); checkCompletedNormally(g, v2); }} @@ -2971,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 /** @@ -3144,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),