--- jsr166/src/test/tck/CompletableFutureTest.java 2013/03/31 18:16:35 1.12 +++ jsr166/src/test/tck/CompletableFutureTest.java 2014/06/06 19:48:38 1.70 @@ -16,6 +16,9 @@ import java.util.concurrent.ExecutionExc import java.util.concurrent.Future; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +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; @@ -55,6 +58,9 @@ public class CompletableFutureTest exten void checkCompletedNormally(CompletableFuture f, T value) { try { + assertEquals(value, f.get(LONG_DELAY_MS, MILLISECONDS)); + } catch (Throwable fail) { threadUnexpectedException(fail); } + try { assertEquals(value, f.join()); } catch (Throwable fail) { threadUnexpectedException(fail); } try { @@ -63,16 +69,20 @@ public class CompletableFutureTest exten try { assertEquals(value, f.get()); } catch (Throwable fail) { threadUnexpectedException(fail); } - try { - assertEquals(value, f.get(0L, SECONDS)); - } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); assertFalse(f.isCancelled()); + assertFalse(f.isCompletedExceptionally()); assertTrue(f.toString().contains("[Completed normally]")); } void checkCompletedWithWrappedCFException(CompletableFuture f) { try { + f.get(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof CFException); + } catch (Throwable fail) { threadUnexpectedException(fail); } + try { f.join(); shouldThrow(); } catch (CompletionException success) { @@ -90,18 +100,49 @@ public class CompletableFutureTest exten } catch (ExecutionException success) { assertTrue(success.getCause() instanceof CFException); } catch (Throwable fail) { threadUnexpectedException(fail); } + assertTrue(f.isDone()); + assertFalse(f.isCancelled()); + assertTrue(f.toString().contains("[Completed exceptionally]")); + } + + void checkCompletedWithWrappedCFException(CompletableFuture f, + CFException ex) { try { - f.get(0L, SECONDS); + f.get(LONG_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof CFException); + assertSame(ex, success.getCause()); + } catch (Throwable fail) { threadUnexpectedException(fail); } + try { + f.join(); + shouldThrow(); + } catch (CompletionException success) { + assertSame(ex, success.getCause()); + } + try { + f.getNow(null); + shouldThrow(); + } catch (CompletionException success) { + assertSame(ex, success.getCause()); + } + try { + f.get(); + shouldThrow(); + } catch (ExecutionException success) { + assertSame(ex, success.getCause()); } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); assertFalse(f.isCancelled()); + assertTrue(f.toString().contains("[Completed exceptionally]")); } void checkCancelled(CompletableFuture f) { try { + f.get(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (CancellationException success) { + } catch (Throwable fail) { threadUnexpectedException(fail); } + try { f.join(); shouldThrow(); } catch (CancellationException success) {} @@ -114,17 +155,20 @@ public class CompletableFutureTest exten shouldThrow(); } catch (CancellationException success) { } catch (Throwable fail) { threadUnexpectedException(fail); } - try { - f.get(0L, SECONDS); - shouldThrow(); - } catch (CancellationException success) { - } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); + assertTrue(f.isCompletedExceptionally()); assertTrue(f.isCancelled()); + assertTrue(f.toString().contains("[Completed exceptionally]")); } void checkCompletedWithWrappedCancellationException(CompletableFuture f) { try { + f.get(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof CancellationException); + } catch (Throwable fail) { threadUnexpectedException(fail); } + try { f.join(); shouldThrow(); } catch (CompletionException success) { @@ -142,14 +186,10 @@ public class CompletableFutureTest exten } catch (ExecutionException success) { assertTrue(success.getCause() instanceof CancellationException); } catch (Throwable fail) { threadUnexpectedException(fail); } - try { - f.get(0L, SECONDS); - shouldThrow(); - } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof CancellationException); - } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); assertFalse(f.isCancelled()); + assertTrue(f.isCompletedExceptionally()); + assertTrue(f.toString().contains("[Completed exceptionally]")); } /** @@ -157,7 +197,7 @@ public class CompletableFutureTest exten * by methods isDone, isCancelled, and getNow */ public void testConstructor() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); } @@ -166,7 +206,7 @@ public class CompletableFutureTest exten * isCancelled, join, get, and getNow */ public void testComplete() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); f.complete(one); checkCompletedNormally(f, one); @@ -177,7 +217,7 @@ public class CompletableFutureTest exten * methods isDone, isCancelled, join, get, and getNow */ public void testCompleteExceptionally() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(f); @@ -188,7 +228,7 @@ public class CompletableFutureTest exten * methods isDone, isCancelled, join, get, and getNow */ public void testCancel() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); assertTrue(f.cancel(true)); checkCancelled(f); @@ -198,7 +238,7 @@ public class CompletableFutureTest exten * obtrudeValue forces completion with given value */ public void testObtrudeValue() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); f.complete(one); checkCompletedNormally(f, one); @@ -206,10 +246,12 @@ public class CompletableFutureTest exten checkCompletedNormally(f, three); f.obtrudeValue(two); checkCompletedNormally(f, two); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.obtrudeValue(three); checkCompletedNormally(f, three); - f = new CompletableFuture(); + f.obtrudeValue(null); + checkCompletedNormally(f, null); + f = new CompletableFuture<>(); f.completeExceptionally(new CFException()); f.obtrudeValue(four); checkCompletedNormally(f, four); @@ -219,16 +261,16 @@ public class CompletableFutureTest exten * obtrudeException forces completion with given exception */ public void testObtrudeException() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); f.complete(one); checkCompletedNormally(f, one); f.obtrudeException(new CFException()); checkCompletedWithWrappedCFException(f); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.obtrudeException(new CFException()); checkCompletedWithWrappedCFException(f); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.completeExceptionally(new CFException()); f.obtrudeValue(four); checkCompletedNormally(f, four); @@ -240,20 +282,19 @@ public class CompletableFutureTest exten * getNumberOfDependents returns number of dependent tasks */ public void testGetNumberOfDependents() { - CompletableFuture f = new CompletableFuture(); - assertEquals(f.getNumberOfDependents(), 0); - CompletableFuture g = f.thenRun(new Noop()); - assertEquals(f.getNumberOfDependents(), 1); - assertEquals(g.getNumberOfDependents(), 0); - CompletableFuture h = f.thenRun(new Noop()); - assertEquals(f.getNumberOfDependents(), 2); + CompletableFuture f = new CompletableFuture<>(); + assertEquals(0, f.getNumberOfDependents()); + CompletableFuture g = f.thenRun(new Noop(ExecutionMode.DEFAULT)); + assertEquals(1, f.getNumberOfDependents()); + assertEquals(0, g.getNumberOfDependents()); + CompletableFuture h = f.thenRun(new Noop(ExecutionMode.DEFAULT)); + assertEquals(2, f.getNumberOfDependents()); f.complete(1); checkCompletedNormally(g, null); - assertEquals(f.getNumberOfDependents(), 0); - assertEquals(g.getNumberOfDependents(), 0); + assertEquals(0, f.getNumberOfDependents()); + assertEquals(0, g.getNumberOfDependents()); } - /** * toString indicates current completion state */ @@ -279,2059 +320,2279 @@ public class CompletableFutureTest exten checkCompletedNormally(f, "test"); } - static final Supplier supplyOne = - () -> Integer.valueOf(1); - static final Function inc = - (Integer x) -> Integer.valueOf(x.intValue() + 1); - static final BiFunction add = - (Integer x, Integer y) -> Integer.valueOf(x.intValue() + y.intValue()); - static final class IncAction implements Consumer { - int value; - public void accept(Integer x) { value = x.intValue() + 1; } - } - static final class AddAction implements BiConsumer { - int value; - public void accept(Integer x, Integer y) { - value = x.intValue() + y.intValue(); + abstract class CheckedAction { + int invocationCount = 0; + final ExecutionMode m; + CheckedAction(ExecutionMode m) { this.m = m; } + void invoked() { + m.checkExecutionMode(); + assertEquals(0, invocationCount++); } - } - static final class Noop implements Runnable { - boolean ran; - public void run() { ran = true; } - } - - static final class FailingSupplier implements Supplier { - boolean ran; - public Integer get() { ran = true; throw new CFException(); } - } - static final class FailingConsumer implements Consumer { - boolean ran; - public void accept(Integer x) { ran = true; throw new CFException(); } - } - static final class FailingBiConsumer implements BiConsumer { - boolean ran; - public void accept(Integer x, Integer y) { ran = true; throw new CFException(); } - } - static final class FailingFunction implements Function { - boolean ran; - public Integer apply(Integer x) { ran = true; throw new CFException(); } - } - static final class FailingBiFunction implements BiFunction { - boolean ran; - public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); } - } - static final class FailingNoop implements Runnable { - boolean ran; - public void run() { ran = true; throw new CFException(); } + void assertNotInvoked() { assertEquals(0, invocationCount); } + void assertInvoked() { assertEquals(1, invocationCount); } } - static final class CompletableFutureInc implements Function> { - public CompletableFuture apply(Integer x) { - CompletableFuture f = new CompletableFuture(); - f.complete(Integer.valueOf(x.intValue() + 1)); - return f; + abstract class CheckedIntegerAction extends CheckedAction { + Integer value; + CheckedIntegerAction(ExecutionMode m) { super(m); } + void assertValue(Integer expected) { + assertInvoked(); + assertEquals(expected, value); } } - static final class FailingCompletableFutureFunction implements Function> { - boolean ran; - public CompletableFuture apply(Integer x) { - ran = true; throw new CFException(); + class IntegerSupplier extends CheckedAction + implements Supplier + { + final Integer value; + IntegerSupplier(ExecutionMode m, Integer value) { + super(m); + this.value = value; } - } - - // Used for explicit executor tests - static final class ThreadExecutor implements Executor { - public void execute(Runnable r) { - new Thread(r).start(); + public Integer get() { + invoked(); + return value; } } - static final class ExceptionToInteger implements Function { - public Integer apply(Throwable x) { return Integer.valueOf(3); } + // A function that handles and produces null values as well. + static Integer inc(Integer x) { + return (x == null) ? null : x + 1; } - static final class IntegerHandler implements BiFunction { - public Integer apply(Integer x, Throwable t) { - return (t == null) ? two : three; + class NoopConsumer extends CheckedIntegerAction + implements Consumer + { + NoopConsumer(ExecutionMode m) { super(m); } + public void accept(Integer x) { + invoked(); + value = x; } } - - /** - * exceptionally action completes with function value on source - * exception; otherwise with source value - */ - public void testExceptionally() { - CompletableFuture f = new CompletableFuture(); - ExceptionToInteger r = new ExceptionToInteger(); - CompletableFuture g = f.exceptionally(r); - f.completeExceptionally(new CFException()); - checkCompletedNormally(g, three); - - f = new CompletableFuture(); - r = new ExceptionToInteger(); - g = f.exceptionally(r); - f.complete(one); - checkCompletedNormally(g, one); - } - - /** - * handle action completes normally with function value on either - * normal or exceptional completion of source - */ - public void testHandle() { - CompletableFuture f = new CompletableFuture(); - IntegerHandler r = new IntegerHandler(); - CompletableFuture g = f.handle(r); - f.completeExceptionally(new CFException()); - checkCompletedNormally(g, three); - - f = new CompletableFuture(); - r = new IntegerHandler(); - g = f.handle(r); - f.complete(one); - checkCompletedNormally(g, two); - } - - /** - * runAsync completes after running Runnable - */ - public void testRunAsync() { - Noop r = new Noop(); - CompletableFuture f = CompletableFuture.runAsync(r); - assertNull(f.join()); - assertTrue(r.ran); - } - - /** - * runAsync with executor completes after running Runnable - */ - public void testRunAsync2() { - Noop r = new Noop(); - CompletableFuture f = CompletableFuture.runAsync(r, new ThreadExecutor()); - assertNull(f.join()); - assertTrue(r.ran); - } - - /** - * failing runAsync completes exceptionally after running Runnable - */ - public void testRunAsync3() { - FailingNoop r = new FailingNoop(); - CompletableFuture f = CompletableFuture.runAsync(r); - checkCompletedWithWrappedCFException(f); - assertTrue(r.ran); - } - - /** - * supplyAsync completes with result of supplier - */ - public void testSupplyAsync() { - CompletableFuture f = CompletableFuture.supplyAsync(supplyOne); - assertEquals(f.join(), one); - } - - /** - * supplyAsync with executor completes with result of supplier - */ - public void testSupplyAsync2() { - CompletableFuture f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor()); - assertEquals(f.join(), one); - } - - /** - * Failing supplyAsync completes exceptionally - */ - public void testSupplyAsync3() { - FailingSupplier r = new FailingSupplier(); - CompletableFuture f = CompletableFuture.supplyAsync(r); - checkCompletedWithWrappedCFException(f); - assertTrue(r.ran); - } - - // seq completion methods - - /** - * thenRun result completes normally after normal completion of source - */ - public void testThenRun() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRun(r); - f.complete(null); - checkCompletedNormally(g, null); - // reordered version - f = new CompletableFuture(); - f.complete(null); - r = new Noop(); - g = f.thenRun(r); - checkCompletedNormally(g, null); - } - - /** - * thenRun result completes exceptionally after exceptional - * completion of source - */ - public void testThenRun2() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRun(r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenRun result completes exceptionally if action does - */ - public void testThenRun3() { - CompletableFuture f = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.thenRun(r); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenRun result completes exceptionally if source cancelled - */ - public void testThenRun4() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRun(r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * thenApply result completes normally after normal completion of source - */ - public void testThenApply() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApply(inc); - f.complete(one); - checkCompletedNormally(g, two); - } - - /** - * thenApply result completes exceptionally after exceptional - * completion of source - */ - public void testThenApply2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApply(inc); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + class IncFunction extends CheckedIntegerAction + implements Function + { + IncFunction(ExecutionMode m) { super(m); } + public Integer apply(Integer x) { + invoked(); + return value = inc(x); + } } - /** - * thenApply result completes exceptionally if action does - */ - public void testThenApply3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApply(new FailingFunction()); - f.complete(one); - checkCompletedWithWrappedCFException(g); + // Choose non-commutative actions for better coverage + // A non-commutative function that handles and produces null values as well. + static Integer subtract(Integer x, Integer y) { + return (x == null && y == null) ? null : + ((x == null) ? 42 : x.intValue()) + - ((y == null) ? 99 : y.intValue()); } - /** - * thenApply result completes exceptionally if source cancelled - */ - public void testThenApply4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApply(inc); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + class SubtractAction extends CheckedIntegerAction + implements BiConsumer + { + SubtractAction(ExecutionMode m) { super(m); } + public void accept(Integer x, Integer y) { + invoked(); + value = subtract(x, y); + } } - /** - * thenAccept result completes normally after normal completion of source - */ - public void testThenAccept() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAccept(r); - f.complete(one); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); + class SubtractFunction extends CheckedIntegerAction + implements BiFunction + { + SubtractFunction(ExecutionMode m) { super(m); } + public Integer apply(Integer x, Integer y) { + invoked(); + return value = subtract(x, y); + } } - /** - * thenAccept result completes exceptionally after exceptional - * completion of source - */ - public void testThenAccept2() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAccept(r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + class Noop extends CheckedAction implements Runnable { + Noop(ExecutionMode m) { super(m); } + public void run() { + invoked(); + } } - /** - * thenAccept result completes exceptionally if action does - */ - public void testThenAccept3() { - CompletableFuture f = new CompletableFuture(); - FailingConsumer r = new FailingConsumer(); - CompletableFuture g = f.thenAccept(r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - assertTrue(r.ran); + class FailingSupplier extends CheckedAction + implements Supplier + { + FailingSupplier(ExecutionMode m) { super(m); } + public Integer get() { + invoked(); + throw new CFException(); + } } - /** - * thenAccept result completes exceptionally if source cancelled - */ - public void testThenAccept4() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAccept(r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + class FailingConsumer extends CheckedIntegerAction + implements Consumer + { + FailingConsumer(ExecutionMode m) { super(m); } + public void accept(Integer x) { + invoked(); + value = x; + throw new CFException(); + } } - - /** - * thenCombine result completes normally after normal completion of sources - */ - public void testThenCombine() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombine(f2, add); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, three); - - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.thenCombine(f2, add); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, three); + class FailingBiConsumer extends CheckedIntegerAction + implements BiConsumer + { + FailingBiConsumer(ExecutionMode m) { super(m); } + public void accept(Integer x, Integer y) { + invoked(); + value = subtract(x, y); + throw new CFException(); + } } - /** - * thenCombine result completes exceptionally after exceptional - * completion of either source - */ - public void testThenCombine2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombine(f2, add); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.thenCombine(f2, add); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + class FailingFunction extends CheckedIntegerAction + implements Function + { + FailingFunction(ExecutionMode m) { super(m); } + public Integer apply(Integer x) { + invoked(); + value = x; + throw new CFException(); + } } - /** - * thenCombine result completes exceptionally if action does - */ - public void testThenCombine3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingBiFunction r = new FailingBiFunction(); - CompletableFuture g = f.thenCombine(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); + class FailingBiFunction extends CheckedIntegerAction + implements BiFunction + { + FailingBiFunction(ExecutionMode m) { super(m); } + public Integer apply(Integer x, Integer y) { + invoked(); + value = subtract(x, y); + throw new CFException(); + } } - /** - * thenCombine result completes exceptionally if either source cancelled - */ - public void testThenCombine4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombine(f2, add); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenCombine(f2, add); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + class FailingRunnable extends CheckedAction implements Runnable { + FailingRunnable(ExecutionMode m) { super(m); } + public void run() { + invoked(); + throw new CFException(); + } } - /** - * thenAcceptBoth result completes normally after normal - * completion of sources - */ - public void testThenAcceptBoth() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBoth(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertEquals(r.value, 3); - r = new AddAction(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.thenAcceptBoth(f2, r); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertEquals(r.value, 3); + class CompletableFutureInc extends CheckedIntegerAction + implements Function> + { + CompletableFutureInc(ExecutionMode m) { super(m); } + public CompletableFuture apply(Integer x) { + invoked(); + value = x; + CompletableFuture f = new CompletableFuture<>(); + f.complete(inc(x)); + return f; + } } - /** - * thenAcceptBoth result completes exceptionally after exceptional - * completion of either source - */ - public void testThenAcceptBoth2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBoth(f2, r); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - - r = new AddAction(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.thenAcceptBoth(f2, r); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + class FailingCompletableFutureFunction extends CheckedIntegerAction + implements Function> + { + FailingCompletableFutureFunction(ExecutionMode m) { super(m); } + public CompletableFuture apply(Integer x) { + invoked(); + value = x; + throw new CFException(); + } } - /** - * thenAcceptBoth result completes exceptionally if action does - */ - public void testThenAcceptBoth3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingBiConsumer r = new FailingBiConsumer(); - CompletableFuture g = f.thenAcceptBoth(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + // Used for explicit executor tests + static final class ThreadExecutor implements Executor { + final AtomicInteger count = new AtomicInteger(0); + static final ThreadGroup tg = new ThreadGroup("ThreadExecutor"); + static boolean startedCurrentThread() { + return Thread.currentThread().getThreadGroup() == tg; + } - /** - * thenAcceptBoth result completes exceptionally if either source cancelled - */ - public void testThenAcceptBoth4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBoth(f2, r); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - r = new AddAction(); - g = f.thenAcceptBoth(f2, r); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + public void execute(Runnable r) { + count.getAndIncrement(); + new Thread(tg, r).start(); + } } /** - * runAfterBoth result completes normally after normal - * completion of sources + * Permits the testing of parallel code for the 3 different + * execution modes without copy/pasting all the test methods. */ - public void testRunAfterBoth() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBoth(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertTrue(r.ran); - - r = new Noop(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.runAfterBoth(f2, r); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertTrue(r.ran); - } + enum ExecutionMode { + DEFAULT { + public void checkExecutionMode() { + assertFalse(ThreadExecutor.startedCurrentThread()); + assertNull(ForkJoinTask.getPool()); + } + public CompletableFuture runAsync(Runnable a) { + throw new UnsupportedOperationException(); + } + public CompletableFuture supplyAsync(Supplier a) { + throw new UnsupportedOperationException(); + } + public CompletableFuture thenRun + (CompletableFuture f, Runnable a) { + return f.thenRun(a); + } + public CompletableFuture thenAccept + (CompletableFuture f, Consumer a) { + return f.thenAccept(a); + } + public CompletableFuture thenApply + (CompletableFuture f, Function a) { + return f.thenApply(a); + } + public CompletableFuture thenCompose + (CompletableFuture f, + Function> a) { + return f.thenCompose(a); + } + public CompletableFuture handle + (CompletableFuture f, + BiFunction a) { + return f.handle(a); + } + public CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a) { + return f.whenComplete(a); + } + public CompletableFuture runAfterBoth + (CompletableFuture f, CompletableFuture g, Runnable a) { + return f.runAfterBoth(g, a); + } + public CompletableFuture thenAcceptBoth + (CompletableFuture f, + CompletionStage g, + BiConsumer a) { + return f.thenAcceptBoth(g, a); + } + public CompletableFuture thenCombine + (CompletableFuture f, + CompletionStage g, + BiFunction a) { + return f.thenCombine(g, a); + } + public CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a) { + return f.runAfterEither(g, a); + } + public CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a) { + return f.acceptEither(g, a); + } + public CompletableFuture applyToEither + (CompletableFuture f, + CompletionStage g, + Function a) { + return f.applyToEither(g, a); + } + }, - /** - * runAfterBoth result completes exceptionally after exceptional - * completion of either source - */ - public void testRunAfterBoth2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBoth(f2, r); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); + ASYNC { + public void checkExecutionMode() { + assertSame(ForkJoinPool.commonPool(), + ForkJoinTask.getPool()); + } + public CompletableFuture runAsync(Runnable a) { + return CompletableFuture.runAsync(a); + } + public CompletableFuture supplyAsync(Supplier a) { + return CompletableFuture.supplyAsync(a); + } + public CompletableFuture thenRun + (CompletableFuture f, Runnable a) { + return f.thenRunAsync(a); + } + public CompletableFuture thenAccept + (CompletableFuture f, Consumer a) { + return f.thenAcceptAsync(a); + } + public CompletableFuture thenApply + (CompletableFuture f, Function a) { + return f.thenApplyAsync(a); + } + public CompletableFuture thenCompose + (CompletableFuture f, + Function> a) { + return f.thenComposeAsync(a); + } + public CompletableFuture handle + (CompletableFuture f, + BiFunction a) { + return f.handleAsync(a); + } + public CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a) { + return f.whenCompleteAsync(a); + } + public CompletableFuture runAfterBoth + (CompletableFuture f, CompletableFuture g, Runnable a) { + return f.runAfterBothAsync(g, a); + } + public CompletableFuture thenAcceptBoth + (CompletableFuture f, + CompletionStage g, + BiConsumer a) { + return f.thenAcceptBothAsync(g, a); + } + public CompletableFuture thenCombine + (CompletableFuture f, + CompletionStage g, + BiFunction a) { + return f.thenCombineAsync(g, a); + } + public CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a) { + return f.runAfterEitherAsync(g, a); + } + public CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a) { + return f.acceptEitherAsync(g, a); + } + public CompletableFuture applyToEither + (CompletableFuture f, + CompletionStage g, + Function a) { + return f.applyToEitherAsync(g, a); + } + }, - r = new Noop(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.runAfterBoth(f2, r); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + EXECUTOR { + public void checkExecutionMode() { + assertTrue(ThreadExecutor.startedCurrentThread()); + } + public CompletableFuture runAsync(Runnable a) { + return CompletableFuture.runAsync(a, new ThreadExecutor()); + } + public CompletableFuture supplyAsync(Supplier a) { + return CompletableFuture.supplyAsync(a, new ThreadExecutor()); + } + public CompletableFuture thenRun + (CompletableFuture f, Runnable a) { + return f.thenRunAsync(a, new ThreadExecutor()); + } + public CompletableFuture thenAccept + (CompletableFuture f, Consumer a) { + return f.thenAcceptAsync(a, new ThreadExecutor()); + } + public CompletableFuture thenApply + (CompletableFuture f, Function a) { + return f.thenApplyAsync(a, new ThreadExecutor()); + } + public CompletableFuture thenCompose + (CompletableFuture f, + Function> a) { + return f.thenComposeAsync(a, new ThreadExecutor()); + } + public CompletableFuture handle + (CompletableFuture f, + BiFunction a) { + return f.handleAsync(a, new ThreadExecutor()); + } + public CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a) { + return f.whenCompleteAsync(a, new ThreadExecutor()); + } + public CompletableFuture runAfterBoth + (CompletableFuture f, CompletableFuture g, Runnable a) { + return f.runAfterBothAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture thenAcceptBoth + (CompletableFuture f, + CompletionStage g, + BiConsumer a) { + return f.thenAcceptBothAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture thenCombine + (CompletableFuture f, + CompletionStage g, + BiFunction a) { + return f.thenCombineAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a) { + return f.runAfterEitherAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a) { + return f.acceptEitherAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture applyToEither + (CompletableFuture f, + CompletionStage g, + Function a) { + return f.applyToEitherAsync(g, a, new ThreadExecutor()); + } + }; - /** - * runAfterBoth result completes exceptionally if action does - */ - public void testRunAfterBoth3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.runAfterBoth(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + public abstract void checkExecutionMode(); + public abstract CompletableFuture runAsync(Runnable a); + public abstract CompletableFuture supplyAsync(Supplier a); + public abstract CompletableFuture thenRun + (CompletableFuture f, Runnable a); + public abstract CompletableFuture thenAccept + (CompletableFuture f, Consumer a); + public abstract CompletableFuture thenApply + (CompletableFuture f, Function a); + public abstract CompletableFuture thenCompose + (CompletableFuture f, + Function> a); + public abstract CompletableFuture handle + (CompletableFuture f, + BiFunction a); + public abstract CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a); + public abstract CompletableFuture runAfterBoth + (CompletableFuture f, CompletableFuture g, Runnable a); + public abstract CompletableFuture thenAcceptBoth + (CompletableFuture f, + CompletionStage g, + BiConsumer a); + public abstract CompletableFuture thenCombine + (CompletableFuture f, + CompletionStage g, + BiFunction a); + public abstract CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a); + public abstract CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a); + public abstract CompletableFuture applyToEither + (CompletableFuture f, + CompletionStage g, + Function a); + } + + /** + * exceptionally action is not invoked when source completes + * normally, and source result is propagated + */ + public void testExceptionally_normalCompletion() { + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = f.exceptionally + ((Throwable t) -> { + // Should not be called + a.getAndIncrement(); + throw new AssertionError(); + }); + if (createIncomplete) f.complete(v1); + + checkCompletedNormally(g, v1); + checkCompletedNormally(f, v1); + assertEquals(0, a.get()); + }} - /** - * runAfterBoth result completes exceptionally if either source cancelled - */ - public void testRunAfterBoth4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBoth(f2, r); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - r = new Noop(); - g = f.runAfterBoth(f2, r); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } /** - * applyToEither result completes normally after normal completion - * of either source + * exceptionally action completes with function value on source + * exception */ - public void testApplyToEither() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEither(f2, inc); - f.complete(one); - checkCompletedNormally(g, two); - f2.complete(one); - checkCompletedNormally(g, two); - - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.applyToEither(f2, inc); - checkCompletedNormally(g, two); - } + public void testExceptionally_exceptionalCompletion() { + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = f.exceptionally + ((Throwable t) -> { + ExecutionMode.DEFAULT.checkExecutionMode(); + threadAssertSame(t, ex); + a.getAndIncrement(); + return v1; + }); + if (createIncomplete) f.completeExceptionally(ex); + + checkCompletedNormally(g, v1); + assertEquals(1, a.get()); + }} + + public void testExceptionally_exceptionalCompletionActionFailed() { + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CFException ex1 = new CFException(); + final CFException ex2 = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.completeExceptionally(ex1); + final CompletableFuture g = f.exceptionally + ((Throwable t) -> { + ExecutionMode.DEFAULT.checkExecutionMode(); + threadAssertSame(t, ex1); + a.getAndIncrement(); + throw ex2; + }); + if (createIncomplete) f.completeExceptionally(ex1); + + checkCompletedWithWrappedCFException(g, ex2); + assertEquals(1, a.get()); + }} + + /** + * handle action completes normally with function value on normal + * completion of source + */ + public void testHandle_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final AtomicInteger a = new AtomicInteger(0); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.handle + (f, + (Integer x, Throwable t) -> { + m.checkExecutionMode(); + threadAssertSame(x, v1); + threadAssertNull(t); + a.getAndIncrement(); + return inc(v1); + }); + if (createIncomplete) f.complete(v1); + + checkCompletedNormally(g, inc(v1)); + checkCompletedNormally(f, v1); + assertEquals(1, a.get()); + }} /** - * applyToEither result completes exceptionally after exceptional - * completion of either source + * handle action completes normally with function value on + * exceptional completion of source */ - public void testApplyToEither2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEither(f2, inc); - f.completeExceptionally(new CFException()); - f2.complete(one); - checkCompletedWithWrappedCFException(g); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.applyToEither(f2, inc); - checkCompletedWithWrappedCFException(g); - } + public void testHandle_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final AtomicInteger a = new AtomicInteger(0); + final CFException ex = new CFException(); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = m.handle + (f, + (Integer x, Throwable t) -> { + m.checkExecutionMode(); + threadAssertNull(x); + threadAssertSame(t, ex); + a.getAndIncrement(); + return v1; + }); + if (createIncomplete) f.completeExceptionally(ex); + + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCFException(f, ex); + assertEquals(1, a.get()); + }} + + /** + * handle action completes normally with function value on + * cancelled source + */ + public void testHandle_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final AtomicInteger a = new AtomicInteger(0); + if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); + final CompletableFuture g = m.handle + (f, + (Integer x, Throwable t) -> { + m.checkExecutionMode(); + threadAssertNull(x); + threadAssertTrue(t instanceof CancellationException); + a.getAndIncrement(); + return v1; + }); + if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); - /** - * applyToEither result completes exceptionally if action does - */ - public void testApplyToEither3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingFunction r = new FailingFunction(); - CompletableFuture g = f.applyToEither(f2, r); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(g, v1); + checkCancelled(f); + assertEquals(1, a.get()); + }} /** - * applyToEither result completes exceptionally if either source cancelled + * handle result completes exceptionally if action does */ - public void testApplyToEither4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEither(f2, inc); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + public void testHandle_sourceFailedActionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + { + final CompletableFuture f = new CompletableFuture<>(); + final AtomicInteger a = new AtomicInteger(0); + final CFException ex1 = new CFException(); + final CFException ex2 = new CFException(); + if (!createIncomplete) f.completeExceptionally(ex1); + final CompletableFuture g = m.handle + (f, + (Integer x, Throwable t) -> { + m.checkExecutionMode(); + threadAssertNull(x); + threadAssertSame(ex1, t); + a.getAndIncrement(); + throw ex2; + }); + if (createIncomplete) f.completeExceptionally(ex1); + + checkCompletedWithWrappedCFException(g, ex2); + checkCompletedWithWrappedCFException(f, ex1); + assertEquals(1, a.get()); + }} + + public void testHandle_sourceCompletedNormallyActionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final AtomicInteger a = new AtomicInteger(0); + final CFException ex = new CFException(); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.handle + (f, + (Integer x, Throwable t) -> { + m.checkExecutionMode(); + threadAssertSame(x, v1); + threadAssertNull(t); + a.getAndIncrement(); + throw ex; + }); + if (createIncomplete) f.complete(v1); + + checkCompletedWithWrappedCFException(g, ex); + checkCompletedNormally(f, v1); + assertEquals(1, a.get()); + }} /** - * acceptEither result completes normally after normal completion - * of either source + * runAsync completes after running Runnable */ - public void testAcceptEither() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEither(f2, r); - f.complete(one); - checkCompletedNormally(g, null); - f2.complete(one); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); - - r = new IncAction(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.acceptEither(f2, r); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); - } + public void testRunAsync_normalCompletion() { + ExecutionMode[] executionModes = { + ExecutionMode.ASYNC, + ExecutionMode.EXECUTOR, + }; + for (ExecutionMode m : executionModes) + { + final Noop r = new Noop(m); + final CompletableFuture f = m.runAsync(r); + assertNull(f.join()); + checkCompletedNormally(f, null); + r.assertInvoked(); + }} /** - * acceptEither result completes exceptionally after exceptional - * completion of either source + * failing runAsync completes exceptionally after running Runnable */ - public void testAcceptEither2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEither(f2, r); - f.completeExceptionally(new CFException()); - f2.complete(one); - checkCompletedWithWrappedCFException(g); - - r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.acceptEither(f2, r); - checkCompletedWithWrappedCFException(g); - } + public void testRunAsync_exceptionalCompletion() { + ExecutionMode[] executionModes = { + ExecutionMode.ASYNC, + ExecutionMode.EXECUTOR, + }; + for (ExecutionMode m : executionModes) + { + final FailingRunnable r = new FailingRunnable(m); + final CompletableFuture f = m.runAsync(r); + checkCompletedWithWrappedCFException(f); + r.assertInvoked(); + }} /** - * acceptEither result completes exceptionally if action does + * supplyAsync completes with result of supplier */ - public void testAcceptEither3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingConsumer r = new FailingConsumer(); - CompletableFuture g = f.acceptEither(f2, r); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + public void testSupplyAsync_normalCompletion() { + ExecutionMode[] executionModes = { + ExecutionMode.ASYNC, + ExecutionMode.EXECUTOR, + }; + for (ExecutionMode m : executionModes) + for (Integer v1 : new Integer[] { 1, null }) + { + final IntegerSupplier r = new IntegerSupplier(m, v1); + final CompletableFuture f = m.supplyAsync(r); + assertSame(v1, f.join()); + checkCompletedNormally(f, v1); + r.assertInvoked(); + }} /** - * acceptEither result completes exceptionally if either source cancelled + * Failing supplyAsync completes exceptionally */ - public void testAcceptEither4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEither(f2, r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + public void testSupplyAsync_exceptionalCompletion() { + ExecutionMode[] executionModes = { + ExecutionMode.ASYNC, + ExecutionMode.EXECUTOR, + }; + for (ExecutionMode m : executionModes) + { + FailingSupplier r = new FailingSupplier(m); + CompletableFuture f = m.supplyAsync(r); + checkCompletedWithWrappedCFException(f); + r.assertInvoked(); + }} + // seq completion methods /** - * runAfterEither result completes normally after normal completion - * of either source + * thenRun result completes normally after normal completion of source */ - public void testRunAfterEither() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEither(f2, r); - f.complete(one); - checkCompletedNormally(g, null); - f2.complete(one); - checkCompletedNormally(g, null); - assertTrue(r.ran); + public void testThenRun_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final Noop r = new Noop(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenRun(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.complete(v1); + } - r = new Noop(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.runAfterEither(f2, r); checkCompletedNormally(g, null); - assertTrue(r.ran); - } - - /** - * runAfterEither result completes exceptionally after exceptional - * completion of either source - */ - public void testRunAfterEither2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEither(f2, r); - f.completeExceptionally(new CFException()); - f2.complete(one); - checkCompletedWithWrappedCFException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.runAfterEither(f2, r); - checkCompletedWithWrappedCFException(g); - } - - /** - * runAfterEither result completes exceptionally if action does - */ - public void testRunAfterEither3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.runAfterEither(f2, r); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(f, v1); + r.assertInvoked(); + }} /** - * runAfterEither result completes exceptionally if either source cancelled - */ - public void testRunAfterEither4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEither(f2, r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * thenCompose result completes normally after normal completion of source - */ - public void testThenCompose() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenCompose(r); - f.complete(one); - checkCompletedNormally(g, two); - } - - /** - * thenCompose result completes exceptionally after exceptional + * thenRun result completes exceptionally after exceptional * completion of source */ - public void testThenCompose2() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenCompose(r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenCompose result completes exceptionally if action does - */ - public void testThenCompose3() { - CompletableFuture f = new CompletableFuture(); - FailingCompletableFutureFunction r = new FailingCompletableFutureFunction(); - CompletableFuture g = f.thenCompose(r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenCompose result completes exceptionally if source cancelled - */ - public void testThenCompose4() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenCompose(r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - - - // asyncs - - /** - * thenRunAsync result completes normally after normal completion of source - */ - public void testThenRunAsync() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRunAsync(r); - f.complete(null); - checkCompletedNormally(g, null); + public void testThenRun_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + { + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + final Noop r = new Noop(m); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = m.thenRun(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.completeExceptionally(ex); + } - // reordered version - f = new CompletableFuture(); - f.complete(null); - r = new Noop(); - g = f.thenRunAsync(r); - checkCompletedNormally(g, null); - } + checkCompletedWithWrappedCFException(g, ex); + checkCompletedWithWrappedCFException(f, ex); + r.assertNotInvoked(); + }} /** - * thenRunAsync result completes exceptionally after exceptional - * completion of source + * thenRun result completes exceptionally if source cancelled */ - public void testThenRunAsync2() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRunAsync(r); - f.completeExceptionally(new CFException()); - try { - g.join(); - shouldThrow(); - } catch (Exception ok) { + public void testThenRun_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + { + final CompletableFuture f = new CompletableFuture<>(); + final Noop r = new Noop(m); + if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); + final CompletableFuture g = m.thenRun(f, r); + if (createIncomplete) { + checkIncomplete(g); + assertTrue(f.cancel(mayInterruptIfRunning)); } - checkCompletedWithWrappedCFException(g); - } - - /** - * thenRunAsync result completes exceptionally if action does - */ - public void testThenRunAsync3() { - CompletableFuture f = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.thenRunAsync(r); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } - /** - * thenRunAsync result completes exceptionally if source cancelled - */ - public void testThenRunAsync4() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRunAsync(r); - assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); - } + checkCancelled(f); + r.assertNotInvoked(); + }} /** - * thenApplyAsync result completes normally after normal completion of source + * thenRun result completes exceptionally if action does */ - public void testThenApplyAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApplyAsync(inc); - f.complete(one); - checkCompletedNormally(g, two); - } + public void testThenRun_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final FailingRunnable r = new FailingRunnable(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenRun(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.complete(v1); + } - /** - * thenApplyAsync result completes exceptionally after exceptional - * completion of source - */ - public void testThenApplyAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApplyAsync(inc); - f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(f, v1); + }} /** - * thenApplyAsync result completes exceptionally if action does + * thenApply result completes normally after normal completion of source */ - public void testThenApplyAsync3() { - CompletableFuture f = new CompletableFuture(); - FailingFunction r = new FailingFunction(); - CompletableFuture g = f.thenApplyAsync(r); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } + public void testThenApply_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final IncFunction r = new IncFunction(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenApply(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.complete(v1); + } - /** - * thenApplyAsync result completes exceptionally if source cancelled - */ - public void testThenApplyAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApplyAsync(inc); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedNormally(g, inc(v1)); + checkCompletedNormally(f, v1); + r.assertValue(inc(v1)); + }} /** - * thenAcceptAsync result completes normally after normal + * thenApply result completes exceptionally after exceptional * completion of source */ - public void testThenAcceptAsync() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAcceptAsync(r); - f.complete(one); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); - } + public void testThenApply_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + { + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + final IncFunction r = new IncFunction(m); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = m.thenApply(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.completeExceptionally(ex); + } - /** - * thenAcceptAsync result completes exceptionally after exceptional - * completion of source - */ - public void testThenAcceptAsync2() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAcceptAsync(r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCFException(g, ex); + checkCompletedWithWrappedCFException(f, ex); + r.assertNotInvoked(); + }} /** - * thenAcceptAsync result completes exceptionally if action does + * thenApply result completes exceptionally if source cancelled */ - public void testThenAcceptAsync3() { - CompletableFuture f = new CompletableFuture(); - FailingConsumer r = new FailingConsumer(); - CompletableFuture g = f.thenAcceptAsync(r); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } + public void testThenApply_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + { + final CompletableFuture f = new CompletableFuture<>(); + final IncFunction r = new IncFunction(m); + if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); + final CompletableFuture g = m.thenApply(f, r); + if (createIncomplete) { + checkIncomplete(g); + assertTrue(f.cancel(mayInterruptIfRunning)); + } - /** - * thenAcceptAsync result completes exceptionally if source cancelled - */ - public void testThenAcceptAsync4() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAcceptAsync(r); - assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); - } - /** - * thenCombineAsync result completes normally after normal - * completion of sources - */ - public void testThenCombineAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombineAsync(f2, add); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, three); - } + checkCancelled(f); + r.assertNotInvoked(); + }} /** - * thenCombineAsync result completes exceptionally after exceptional - * completion of source + * thenApply result completes exceptionally if action does */ - public void testThenCombineAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombineAsync(f2, add); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); + public void testThenApply_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final FailingFunction r = new FailingFunction(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenApply(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.complete(v1); + } - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenCombineAsync(f2, add); - f.complete(one); - f2.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(f, v1); + }} /** - * thenCombineAsync result completes exceptionally if action does - */ - public void testThenCombineAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingBiFunction r = new FailingBiFunction(); - CompletableFuture g = f.thenCombineAsync(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenCombineAsync result completes exceptionally if either source cancelled + * thenAccept result completes normally after normal completion of source */ - public void testThenCombineAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombineAsync(f2, add); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenCombineAsync(f2, add); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + public void testThenAccept_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final NoopConsumer r = new NoopConsumer(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenAccept(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.complete(v1); + } - /** - * thenAcceptBothAsync result completes normally after normal - * completion of sources - */ - public void testThenAcceptBothAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); checkCompletedNormally(g, null); - assertEquals(r.value, 3); - } + r.assertValue(v1); + checkCompletedNormally(f, v1); + }} /** - * thenAcceptBothAsync result completes exceptionally after exceptional + * thenAccept result completes exceptionally after exceptional * completion of source */ - public void testThenAcceptBothAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); + public void testThenAccept_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + { + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + final NoopConsumer r = new NoopConsumer(m); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = m.thenAccept(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.completeExceptionally(ex); + } - r = new AddAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenAcceptBothAsync(f2, r); - f.complete(one); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCFException(g, ex); + checkCompletedWithWrappedCFException(f, ex); + r.assertNotInvoked(); + }} /** - * thenAcceptBothAsync result completes exceptionally if action does - */ - public void testThenAcceptBothAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingBiConsumer r = new FailingBiConsumer(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenAcceptBothAsync result completes exceptionally if either source cancelled + * thenAccept result completes exceptionally if source cancelled */ - public void testThenAcceptBothAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); + public void testThenAccept_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + { + final CompletableFuture f = new CompletableFuture<>(); + final NoopConsumer r = new NoopConsumer(m); + if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); + final CompletableFuture g = m.thenAccept(f, r); + if (createIncomplete) { + checkIncomplete(g); + assertTrue(f.cancel(mayInterruptIfRunning)); + } - r = new AddAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenAcceptBothAsync(f2, r); - f.complete(one); - assertTrue(f2.cancel(true)); checkCompletedWithWrappedCancellationException(g); - } - - /** - * runAfterBothAsync result completes normally after normal - * completion of sources - */ - public void testRunAfterBothAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBothAsync(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertTrue(r.ran); - } + checkCancelled(f); + r.assertNotInvoked(); + }} /** - * runAfterBothAsync result completes exceptionally after exceptional - * completion of source + * thenAccept result completes exceptionally if action does */ - public void testRunAfterBothAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBothAsync(f2, r); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.runAfterBothAsync(f2, r); - f.complete(one); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + public void testThenAccept_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final FailingConsumer r = new FailingConsumer(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenAccept(f, r); + if (createIncomplete) { + checkIncomplete(g); + f.complete(v1); + } - /** - * runAfterBothAsync result completes exceptionally if action does - */ - public void testRunAfterBothAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.runAfterBothAsync(f2, r); - f.complete(one); - checkIncomplete(g); - f2.complete(two); checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(f, v1); + }} /** - * runAfterBothAsync result completes exceptionally if either source cancelled + * thenCombine result completes normally after normal completion + * of sources */ - public void testRunAfterBothAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBothAsync(f2, r); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); + public void testThenCombine_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractFunction r = new SubtractFunction(m); + + if (fFirst) f.complete(v1); else g.complete(v2); + if (!createIncomplete) + if (!fFirst) f.complete(v1); else g.complete(v2); + final CompletableFuture h = m.thenCombine(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + r.assertNotInvoked(); + if (!fFirst) f.complete(v1); else g.complete(v2); + } - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.runAfterBothAsync(f2, r); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedNormally(h, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + r.assertValue(subtract(v1, v2)); + }} /** - * applyToEitherAsync result completes normally after normal - * completion of sources + * thenCombine result completes exceptionally after exceptional + * completion of either source */ - public void testApplyToEitherAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc); - f.complete(one); - checkCompletedNormally(g, two); + public void testThenCombine_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final SubtractFunction r = new SubtractFunction(m); + + (fFirst ? f : g).complete(v1); + if (!createIncomplete) + (!fFirst ? f : g).completeExceptionally(ex); + final CompletableFuture h = m.thenCombine(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + (!fFirst ? f : g).completeExceptionally(ex); + } - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.applyToEitherAsync(f2, inc); - checkCompletedNormally(g, two); - } + checkCompletedWithWrappedCFException(h, ex); + r.assertNotInvoked(); + checkCompletedNormally(fFirst ? f : g, v1); + checkCompletedWithWrappedCFException(!fFirst ? f : g, ex); + }} /** - * applyToEitherAsync result completes exceptionally after exceptional - * completion of source + * thenCombine result completes exceptionally if either source cancelled */ - public void testApplyToEitherAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.applyToEitherAsync(f2, inc); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testThenCombine_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractFunction r = new SubtractFunction(m); + + (fFirst ? f : g).complete(v1); + if (!createIncomplete) + assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning)); + final CompletableFuture h = m.thenCombine(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning)); + } - /** - * applyToEitherAsync result completes exceptionally if action does - */ - public void testApplyToEitherAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingFunction r = new FailingFunction(); - CompletableFuture g = f.applyToEitherAsync(f2, r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCancellationException(h); + checkCancelled(!fFirst ? f : g); + r.assertNotInvoked(); + checkCompletedNormally(fFirst ? f : g, v1); + }} /** - * applyToEitherAsync result completes exceptionally if either source cancelled + * thenCombine result completes exceptionally if action does */ - public void testApplyToEitherAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + public void testThenCombine_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final FailingBiFunction r = new FailingBiFunction(m); + final CompletableFuture h = m.thenCombine(f, g, r); + + if (fFirst) { + f.complete(v1); + g.complete(v2); + } else { + g.complete(v2); + f.complete(v1); + } - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.applyToEitherAsync(f2, inc); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * acceptEitherAsync result completes normally after normal + * thenAcceptBoth result completes normally after normal * completion of sources */ - public void testAcceptEitherAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEitherAsync(f2, r); - f.complete(one); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); + public void testThenAcceptBoth_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractAction r = new SubtractAction(m); + + if (fFirst) f.complete(v1); else g.complete(v2); + if (!createIncomplete) + if (!fFirst) f.complete(v1); else g.complete(v2); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + r.assertNotInvoked(); + if (!fFirst) f.complete(v1); else g.complete(v2); + } - r = new IncAction(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.acceptEitherAsync(f2, r); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); - } + checkCompletedNormally(h, null); + r.assertValue(subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * acceptEitherAsync result completes exceptionally after exceptional - * completion of source + * thenAcceptBoth result completes exceptionally after exceptional + * completion of either source */ - public void testAcceptEitherAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEitherAsync(f2, r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - - r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.acceptEitherAsync(f2, r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testThenAcceptBoth_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final SubtractAction r = new SubtractAction(m); + + (fFirst ? f : g).complete(v1); + if (!createIncomplete) + (!fFirst ? f : g).completeExceptionally(ex); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + (!fFirst ? f : g).completeExceptionally(ex); + } - /** - * acceptEitherAsync result completes exceptionally if action does - */ - public void testAcceptEitherAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingConsumer r = new FailingConsumer(); - CompletableFuture g = f.acceptEitherAsync(f2, r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCFException(h, ex); + r.assertNotInvoked(); + checkCompletedNormally(fFirst ? f : g, v1); + checkCompletedWithWrappedCFException(!fFirst ? f : g, ex); + }} /** - * acceptEitherAsync result completes exceptionally if either - * source cancelled + * thenAcceptBoth result completes exceptionally if either source cancelled */ - public void testAcceptEitherAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEitherAsync(f2, r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + public void testThenAcceptBoth_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractAction r = new SubtractAction(m); + + (fFirst ? f : g).complete(v1); + if (!createIncomplete) + assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning)); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning)); + } - r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.acceptEitherAsync(f2, r); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedWithWrappedCancellationException(h); + checkCancelled(!fFirst ? f : g); + r.assertNotInvoked(); + checkCompletedNormally(fFirst ? f : g, v1); + }} /** - * runAfterEitherAsync result completes normally after normal - * completion of sources + * thenAcceptBoth result completes exceptionally if action does */ - public void testRunAfterEitherAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r); - f.complete(one); - checkCompletedNormally(g, null); - assertTrue(r.ran); + public void testThenAcceptBoth_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final FailingBiConsumer r = new FailingBiConsumer(m); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + if (fFirst) { + f.complete(v1); + g.complete(v2); + } else { + g.complete(v2); + f.complete(v1); + } - r = new Noop(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.runAfterEitherAsync(f2, r); - checkCompletedNormally(g, null); - assertTrue(r.ran); - } + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * runAfterEitherAsync result completes exceptionally after exceptional - * completion of source + * runAfterBoth result completes normally after normal + * completion of sources */ - public void testRunAfterEitherAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.runAfterEitherAsync(f2, r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testRunAfterBoth_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop r = new Noop(m); + + if (fFirst) f.complete(v1); else g.complete(v2); + if (!createIncomplete) + if (!fFirst) f.complete(v1); else g.complete(v2); + final CompletableFuture h = m.runAfterBoth(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + r.assertNotInvoked(); + if (!fFirst) f.complete(v1); else g.complete(v2); + } - /** - * runAfterEitherAsync result completes exceptionally if action does - */ - public void testRunAfterEitherAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(h, null); + r.assertInvoked(); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * runAfterEitherAsync result completes exceptionally if either - * source cancelled + * runAfterBoth result completes exceptionally after exceptional + * completion of either source */ - public void testRunAfterEitherAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.runAfterEitherAsync(f2, r); - checkCompletedWithWrappedCancellationException(g); - } + public void testRunAfterBoth_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final Noop r = new Noop(m); + + (fFirst ? f : g).complete(v1); + if (!createIncomplete) + (!fFirst ? f : g).completeExceptionally(ex); + final CompletableFuture h = m.runAfterBoth(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + (!fFirst ? f : g).completeExceptionally(ex); + } - /** - * thenComposeAsync result completes normally after normal - * completion of source - */ - public void testThenComposeAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenComposeAsync(r); - f.complete(one); - checkCompletedNormally(g, two); - } + checkCompletedWithWrappedCFException(h, ex); + r.assertNotInvoked(); + checkCompletedNormally(fFirst ? f : g, v1); + checkCompletedWithWrappedCFException(!fFirst ? f : g, ex); + }} /** - * thenComposeAsync result completes exceptionally after - * exceptional completion of source + * runAfterBoth result completes exceptionally if either source cancelled */ - public void testThenComposeAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenComposeAsync(r); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + public void testRunAfterBoth_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop r = new Noop(m); + + + (fFirst ? f : g).complete(v1); + if (!createIncomplete) + assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning)); + final CompletableFuture h = m.runAfterBoth(f, g, r); + if (createIncomplete) { + checkIncomplete(h); + assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning)); + } - /** - * thenComposeAsync result completes exceptionally if action does - */ - public void testThenComposeAsync3() { - CompletableFuture f = new CompletableFuture(); - FailingCompletableFutureFunction r = new FailingCompletableFutureFunction(); - CompletableFuture g = f.thenComposeAsync(r); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCancellationException(h); + checkCancelled(!fFirst ? f : g); + r.assertNotInvoked(); + checkCompletedNormally(fFirst ? f : g, v1); + }} /** - * thenComposeAsync result completes exceptionally if source cancelled + * runAfterBoth result completes exceptionally if action does */ - public void testThenComposeAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenComposeAsync(r); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - + public void testRunAfterBoth_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final FailingRunnable r1 = new FailingRunnable(m); + final FailingRunnable r2 = new FailingRunnable(m); + + CompletableFuture h1 = m.runAfterBoth(f, g, r1); + if (fFirst) { + f.complete(v1); + g.complete(v2); + } else { + g.complete(v2); + f.complete(v1); + } + CompletableFuture h2 = m.runAfterBoth(f, g, r2); - // async with explicit executors + checkCompletedWithWrappedCFException(h1); + checkCompletedWithWrappedCFException(h2); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * thenRunAsync result completes normally after normal completion of source + * applyToEither result completes normally after normal completion + * of either source */ - public void testThenRunAsyncE() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); - f.complete(null); - checkCompletedNormally(g, null); - - // reordered version - f = new CompletableFuture(); - f.complete(null); - r = new Noop(); - g = f.thenRunAsync(r, new ThreadExecutor()); - checkCompletedNormally(g, null); - } + public void testApplyToEither_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction[] rs = new IncFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m); + + final CompletableFuture h0 = m.applyToEither(f, g, rs[0]); + final CompletableFuture h1 = m.applyToEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.complete(v1); + checkCompletedNormally(h0, inc(v1)); + checkCompletedNormally(h1, inc(v1)); + final CompletableFuture h2 = m.applyToEither(f, g, rs[2]); + final CompletableFuture h3 = m.applyToEither(g, f, rs[3]); + checkCompletedNormally(h2, inc(v1)); + checkCompletedNormally(h3, inc(v1)); + g.complete(v2); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.applyToEither(f, g, rs[4]); + final CompletableFuture h5 = m.applyToEither(g, f, rs[5]); + rs[4].assertValue(h4.join()); + rs[5].assertValue(h5.join()); + assertTrue(Objects.equals(inc(v1), h4.join()) || + Objects.equals(inc(v2), h4.join())); + assertTrue(Objects.equals(inc(v1), h5.join()) || + Objects.equals(inc(v2), h5.join())); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + checkCompletedNormally(h0, inc(v1)); + checkCompletedNormally(h1, inc(v1)); + checkCompletedNormally(h2, inc(v1)); + checkCompletedNormally(h3, inc(v1)); + for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1)); + }} /** - * thenRunAsync result completes exceptionally after exceptional - * completion of source + * applyToEither result completes exceptionally after exceptional + * completion of either source */ - public void testThenRunAsync2E() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); + public void testApplyToEither_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final IncFunction[] rs = new IncFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m); + + final CompletableFuture h0 = m.applyToEither(f, g, rs[0]); + final CompletableFuture h1 = m.applyToEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.completeExceptionally(ex); + checkCompletedWithWrappedCFException(h0, ex); + checkCompletedWithWrappedCFException(h1, ex); + final CompletableFuture h2 = m.applyToEither(f, g, rs[2]); + final CompletableFuture h3 = m.applyToEither(g, f, rs[3]); + checkCompletedWithWrappedCFException(h2, ex); + checkCompletedWithWrappedCFException(h3, ex); + g.complete(v1); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.applyToEither(f, g, rs[4]); + final CompletableFuture h5 = m.applyToEither(g, f, rs[5]); try { - g.join(); - shouldThrow(); - } catch (Exception ok) { + assertEquals(inc(v1), h4.join()); + rs[4].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h4, ex); + rs[4].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h5.join()); + rs[5].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h5, ex); + rs[5].assertNotInvoked(); } - checkCompletedWithWrappedCFException(g); - } - - /** - * thenRunAsync result completes exceptionally if action does - */ - public void testThenRunAsync3E() { - CompletableFuture f = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenRunAsync result completes exceptionally if source cancelled - */ - public void testThenRunAsync4E() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * thenApplyAsync result completes normally after normal completion of source - */ - public void testThenApplyAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApplyAsync(inc, new ThreadExecutor()); - f.complete(one); - checkCompletedNormally(g, two); - } - - /** - * thenApplyAsync result completes exceptionally after exceptional - * completion of source - */ - public void testThenApplyAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApplyAsync(inc, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenApplyAsync result completes exceptionally if action does - */ - public void testThenApplyAsync3E() { - CompletableFuture f = new CompletableFuture(); - FailingFunction r = new FailingFunction(); - CompletableFuture g = f.thenApplyAsync(r, new ThreadExecutor()); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenApplyAsync result completes exceptionally if source cancelled - */ - public void testThenApplyAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = f.thenApplyAsync(inc, new ThreadExecutor()); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * thenAcceptAsync result completes normally after normal - * completion of source - */ - public void testThenAcceptAsyncE() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); - f.complete(one); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); - } - - /** - * thenAcceptAsync result completes exceptionally after exceptional - * completion of source - */ - public void testThenAcceptAsync2E() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenAcceptAsync result completes exceptionally if action does - */ - public void testThenAcceptAsync3E() { - CompletableFuture f = new CompletableFuture(); - FailingConsumer r = new FailingConsumer(); - CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); - f.complete(null); - checkCompletedWithWrappedCFException(g); - } - - /** - * thenAcceptAsync result completes exceptionally if source cancelled - */ - public void testThenAcceptAsync4E() { - CompletableFuture f = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - /** - * thenCombineAsync result completes normally after normal - * completion of sources - */ - public void testThenCombineAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombineAsync(f2, add, new ThreadExecutor()); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, three); - } - - /** - * thenCombineAsync result completes exceptionally after exceptional - * completion of source - */ - public void testThenCombineAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombineAsync(f2, add, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenCombineAsync(f2, add, new ThreadExecutor()); - f.complete(one); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } - /** - * thenCombineAsync result completes exceptionally if action does - */ - public void testThenCombineAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingBiFunction r = new FailingBiFunction(); - CompletableFuture g = f.thenCombineAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCFException(f, ex); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCFException(h0, ex); + checkCompletedWithWrappedCFException(h1, ex); + checkCompletedWithWrappedCFException(h2, ex); + checkCompletedWithWrappedCFException(h3, ex); + checkCompletedWithWrappedCFException(h4, ex); + for (int i = 0; i < 4; i++) rs[i].assertNotInvoked(); + }} + + public void testApplyToEither_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final IncFunction[] rs = new IncFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m); + + final CompletableFuture h0 = m.applyToEither(f, g, rs[0]); + final CompletableFuture h1 = m.applyToEither(g, f, rs[1]); + if (fFirst) { + f.complete(v1); + g.completeExceptionally(ex); + } else { + g.completeExceptionally(ex); + f.complete(v1); + } + final CompletableFuture h2 = m.applyToEither(f, g, rs[2]); + final CompletableFuture h3 = m.applyToEither(g, f, rs[3]); - /** - * thenCombineAsync result completes exceptionally if either source cancelled - */ - public void testThenCombineAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.thenCombineAsync(f2, add, new ThreadExecutor()); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); + // unspecified behavior - both source completions available + try { + assertEquals(inc(v1), h0.join()); + rs[0].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h0, ex); + rs[0].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h1.join()); + rs[1].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h1, ex); + rs[1].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h2.join()); + rs[2].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h2, ex); + rs[2].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h3.join()); + rs[3].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h3, ex); + rs[3].assertNotInvoked(); + } - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenCombineAsync(f2, add, new ThreadExecutor()); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedNormally(f, v1); + checkCompletedWithWrappedCFException(g, ex); + }} /** - * thenAcceptBothAsync result completes normally after normal - * completion of sources + * applyToEither result completes exceptionally if either source cancelled */ - public void testThenAcceptBothAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertEquals(r.value, 3); - } + public void testApplyToEither_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction[] rs = new IncFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m); + + final CompletableFuture h0 = m.applyToEither(f, g, rs[0]); + final CompletableFuture h1 = m.applyToEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.cancel(mayInterruptIfRunning); + checkCompletedWithWrappedCancellationException(h0); + checkCompletedWithWrappedCancellationException(h1); + final CompletableFuture h2 = m.applyToEither(f, g, rs[2]); + final CompletableFuture h3 = m.applyToEither(g, f, rs[3]); + checkCompletedWithWrappedCancellationException(h2); + checkCompletedWithWrappedCancellationException(h3); + g.complete(v1); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.applyToEither(f, g, rs[4]); + final CompletableFuture h5 = m.applyToEither(g, f, rs[5]); + try { + assertEquals(inc(v1), h4.join()); + rs[4].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h4); + rs[4].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h5.join()); + rs[5].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h5); + rs[5].assertNotInvoked(); + } - /** - * thenAcceptBothAsync result completes exceptionally after exceptional - * completion of source - */ - public void testThenAcceptBothAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); + checkCancelled(f); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCancellationException(h0); + checkCompletedWithWrappedCancellationException(h1); + checkCompletedWithWrappedCancellationException(h2); + checkCompletedWithWrappedCancellationException(h3); + for (int i = 0; i < 4; i++) rs[i].assertNotInvoked(); + }} + + public void testApplyToEither_sourceCancelled2() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction[] rs = new IncFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m); + + final CompletableFuture h0 = m.applyToEither(f, g, rs[0]); + final CompletableFuture h1 = m.applyToEither(g, f, rs[1]); + if (fFirst) { + f.complete(v1); + g.cancel(mayInterruptIfRunning); + } else { + g.cancel(mayInterruptIfRunning); + f.complete(v1); + } + final CompletableFuture h2 = m.applyToEither(f, g, rs[2]); + final CompletableFuture h3 = m.applyToEither(g, f, rs[3]); - r = new AddAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + // unspecified behavior - both source completions available + try { + assertEquals(inc(v1), h0.join()); + rs[0].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h0); + rs[0].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h1.join()); + rs[1].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h1); + rs[1].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h2.join()); + rs[2].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h2); + rs[2].assertNotInvoked(); + } + try { + assertEquals(inc(v1), h3.join()); + rs[3].assertValue(inc(v1)); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h3); + rs[3].assertNotInvoked(); + } - /** - * thenAcceptBothAsync result completes exceptionally if action does - */ - public void testThenAcceptBothAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingBiConsumer r = new FailingBiConsumer(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(f, v1); + checkCancelled(g); + }} /** - * thenAcceptBothAsync result completes exceptionally if either source cancelled + * applyToEither result completes exceptionally if action does */ - public void testThenAcceptBothAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - AddAction r = new AddAction(); - CompletableFuture g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor()); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); - - r = new AddAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + public void testApplyToEither_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final FailingFunction[] rs = new FailingFunction[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m); + + final CompletableFuture h0 = m.applyToEither(f, g, rs[0]); + final CompletableFuture h1 = m.applyToEither(g, f, rs[1]); + f.complete(v1); + final CompletableFuture h2 = m.applyToEither(f, g, rs[2]); + final CompletableFuture h3 = m.applyToEither(g, f, rs[3]); + checkCompletedWithWrappedCFException(h0); + checkCompletedWithWrappedCFException(h1); + checkCompletedWithWrappedCFException(h2); + checkCompletedWithWrappedCFException(h3); + for (int i = 0; i < 4; i++) rs[i].assertValue(v1); + + g.complete(v2); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.applyToEither(f, g, rs[4]); + final CompletableFuture h5 = m.applyToEither(g, f, rs[5]); + + checkCompletedWithWrappedCFException(h4); + assertTrue(Objects.equals(v1, rs[4].value) || + Objects.equals(v2, rs[4].value)); + checkCompletedWithWrappedCFException(h5); + assertTrue(Objects.equals(v1, rs[5].value) || + Objects.equals(v2, rs[5].value)); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * runAfterBothAsync result completes normally after normal - * completion of sources + * acceptEither result completes normally after normal completion + * of either source */ - public void testRunAfterBothAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedNormally(g, null); - assertTrue(r.ran); - } + public void testAcceptEither_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final NoopConsumer[] rs = new NoopConsumer[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m); + + final CompletableFuture h0 = m.acceptEither(f, g, rs[0]); + final CompletableFuture h1 = m.acceptEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.complete(v1); + checkCompletedNormally(h0, null); + checkCompletedNormally(h1, null); + rs[0].assertValue(v1); + rs[1].assertValue(v1); + final CompletableFuture h2 = m.acceptEither(f, g, rs[2]); + final CompletableFuture h3 = m.acceptEither(g, f, rs[3]); + checkCompletedNormally(h2, null); + checkCompletedNormally(h3, null); + rs[2].assertValue(v1); + rs[3].assertValue(v1); + g.complete(v2); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.acceptEither(f, g, rs[4]); + final CompletableFuture h5 = m.acceptEither(g, f, rs[5]); + checkCompletedNormally(h4, null); + checkCompletedNormally(h5, null); + assertTrue(Objects.equals(v1, rs[4].value) || + Objects.equals(v2, rs[4].value)); + assertTrue(Objects.equals(v1, rs[5].value) || + Objects.equals(v2, rs[5].value)); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + checkCompletedNormally(h0, null); + checkCompletedNormally(h1, null); + checkCompletedNormally(h2, null); + checkCompletedNormally(h3, null); + for (int i = 0; i < 4; i++) rs[i].assertValue(v1); + }} /** - * runAfterBothAsync result completes exceptionally after exceptional - * completion of source + * acceptEither result completes exceptionally after exceptional + * completion of either source */ - public void testRunAfterBothAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBothAsync(f2, r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.runAfterBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } + public void testAcceptEither_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final NoopConsumer[] rs = new NoopConsumer[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m); + + final CompletableFuture h0 = m.acceptEither(f, g, rs[0]); + final CompletableFuture h1 = m.acceptEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.completeExceptionally(ex); + checkCompletedWithWrappedCFException(h0, ex); + checkCompletedWithWrappedCFException(h1, ex); + final CompletableFuture h2 = m.acceptEither(f, g, rs[2]); + final CompletableFuture h3 = m.acceptEither(g, f, rs[3]); + checkCompletedWithWrappedCFException(h2, ex); + checkCompletedWithWrappedCFException(h3, ex); + + g.complete(v1); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.acceptEither(f, g, rs[4]); + final CompletableFuture h5 = m.acceptEither(g, f, rs[5]); + try { + assertNull(h4.join()); + rs[4].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h4, ex); + rs[4].assertNotInvoked(); + } + try { + assertNull(h5.join()); + rs[5].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h5, ex); + rs[5].assertNotInvoked(); + } - /** - * runAfterBothAsync result completes exceptionally if action does - */ - public void testRunAfterBothAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.runAfterBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkIncomplete(g); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - } + checkCompletedWithWrappedCFException(f, ex); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCFException(h0, ex); + checkCompletedWithWrappedCFException(h1, ex); + checkCompletedWithWrappedCFException(h2, ex); + checkCompletedWithWrappedCFException(h3, ex); + checkCompletedWithWrappedCFException(h4, ex); + for (int i = 0; i < 4; i++) rs[i].assertNotInvoked(); + }} + + public void testAcceptEither_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final NoopConsumer[] rs = new NoopConsumer[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m); + + final CompletableFuture h0 = m.acceptEither(f, g, rs[0]); + final CompletableFuture h1 = m.acceptEither(g, f, rs[1]); + if (fFirst) { + f.complete(v1); + g.completeExceptionally(ex); + } else { + g.completeExceptionally(ex); + f.complete(v1); + } + final CompletableFuture h2 = m.acceptEither(f, g, rs[2]); + final CompletableFuture h3 = m.acceptEither(g, f, rs[3]); - /** - * runAfterBothAsync result completes exceptionally if either source cancelled - */ - public void testRunAfterBothAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterBothAsync(f2, r, new ThreadExecutor()); - assertTrue(f.cancel(true)); - f2.complete(two); - checkCompletedWithWrappedCancellationException(g); + // unspecified behavior - both source completions available + try { + assertEquals(null, h0.join()); + rs[0].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h0, ex); + rs[0].assertNotInvoked(); + } + try { + assertEquals(null, h1.join()); + rs[1].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h1, ex); + rs[1].assertNotInvoked(); + } + try { + assertEquals(null, h2.join()); + rs[2].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h2, ex); + rs[2].assertNotInvoked(); + } + try { + assertEquals(null, h3.join()); + rs[3].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h3, ex); + rs[3].assertNotInvoked(); + } - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.runAfterBothAsync(f2, r, new ThreadExecutor()); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedNormally(f, v1); + checkCompletedWithWrappedCFException(g, ex); + }} /** - * applyToEitherAsync result completes normally after normal - * completion of sources + * acceptEither result completes exceptionally if either source cancelled */ - public void testApplyToEitherAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - f.complete(one); - checkCompletedNormally(g, two); + public void testAcceptEither_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final NoopConsumer[] rs = new NoopConsumer[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m); + + final CompletableFuture h0 = m.acceptEither(f, g, rs[0]); + final CompletableFuture h1 = m.acceptEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.cancel(mayInterruptIfRunning); + checkCompletedWithWrappedCancellationException(h0); + checkCompletedWithWrappedCancellationException(h1); + final CompletableFuture h2 = m.acceptEither(f, g, rs[2]); + final CompletableFuture h3 = m.acceptEither(g, f, rs[3]); + checkCompletedWithWrappedCancellationException(h2); + checkCompletedWithWrappedCancellationException(h3); + + g.complete(v1); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.acceptEither(f, g, rs[4]); + final CompletableFuture h5 = m.acceptEither(g, f, rs[5]); + try { + assertNull(h4.join()); + rs[4].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h4); + rs[4].assertNotInvoked(); + } + try { + assertNull(h5.join()); + rs[5].assertValue(v1); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h5); + rs[5].assertNotInvoked(); + } - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - checkCompletedNormally(g, two); - } + checkCancelled(f); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCancellationException(h0); + checkCompletedWithWrappedCancellationException(h1); + checkCompletedWithWrappedCancellationException(h2); + checkCompletedWithWrappedCancellationException(h3); + for (int i = 0; i < 4; i++) rs[i].assertNotInvoked(); + }} /** - * applyToEitherAsync result completes exceptionally after exceptional - * completion of source + * acceptEither result completes exceptionally if action does */ - public void testApplyToEitherAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testAcceptEither_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final FailingConsumer[] rs = new FailingConsumer[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m); + + final CompletableFuture h0 = m.acceptEither(f, g, rs[0]); + final CompletableFuture h1 = m.acceptEither(g, f, rs[1]); + f.complete(v1); + final CompletableFuture h2 = m.acceptEither(f, g, rs[2]); + final CompletableFuture h3 = m.acceptEither(g, f, rs[3]); + checkCompletedWithWrappedCFException(h0); + checkCompletedWithWrappedCFException(h1); + checkCompletedWithWrappedCFException(h2); + checkCompletedWithWrappedCFException(h3); + for (int i = 0; i < 4; i++) rs[i].assertValue(v1); + + g.complete(v2); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.acceptEither(f, g, rs[4]); + final CompletableFuture h5 = m.acceptEither(g, f, rs[5]); + + checkCompletedWithWrappedCFException(h4); + assertTrue(Objects.equals(v1, rs[4].value) || + Objects.equals(v2, rs[4].value)); + checkCompletedWithWrappedCFException(h5); + assertTrue(Objects.equals(v1, rs[5].value) || + Objects.equals(v2, rs[5].value)); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + }} /** - * applyToEitherAsync result completes exceptionally if action does + * runAfterEither result completes normally after normal completion + * of either source */ - public void testApplyToEitherAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingFunction r = new FailingFunction(); - CompletableFuture g = f.applyToEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testRunAfterEither_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop[] rs = new Noop[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m); + + final CompletableFuture h0 = m.runAfterEither(f, g, rs[0]); + final CompletableFuture h1 = m.runAfterEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.complete(v1); + checkCompletedNormally(h0, null); + checkCompletedNormally(h1, null); + rs[0].assertInvoked(); + rs[1].assertInvoked(); + final CompletableFuture h2 = m.runAfterEither(f, g, rs[2]); + final CompletableFuture h3 = m.runAfterEither(g, f, rs[3]); + checkCompletedNormally(h2, null); + checkCompletedNormally(h3, null); + rs[2].assertInvoked(); + rs[3].assertInvoked(); + + g.complete(v2); + + final CompletableFuture h4 = m.runAfterEither(f, g, rs[4]); + final CompletableFuture h5 = m.runAfterEither(g, f, rs[5]); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + checkCompletedNormally(h0, null); + checkCompletedNormally(h1, null); + checkCompletedNormally(h2, null); + checkCompletedNormally(h3, null); + checkCompletedNormally(h4, null); + checkCompletedNormally(h5, null); + for (int i = 0; i < 6; i++) rs[i].assertInvoked(); + }} /** - * applyToEitherAsync result completes exceptionally if either source cancelled + * runAfterEither result completes exceptionally after exceptional + * completion of either source */ - public void testApplyToEitherAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); + public void testRunAfterEither_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final Noop[] rs = new Noop[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m); + + final CompletableFuture h0 = m.runAfterEither(f, g, rs[0]); + final CompletableFuture h1 = m.runAfterEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.completeExceptionally(ex); + checkCompletedWithWrappedCFException(h0, ex); + checkCompletedWithWrappedCFException(h1, ex); + final CompletableFuture h2 = m.runAfterEither(f, g, rs[2]); + final CompletableFuture h3 = m.runAfterEither(g, f, rs[3]); + checkCompletedWithWrappedCFException(h2, ex); + checkCompletedWithWrappedCFException(h3, ex); + + g.complete(v1); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.runAfterEither(f, g, rs[4]); + final CompletableFuture h5 = m.runAfterEither(g, f, rs[5]); + try { + assertNull(h4.join()); + rs[4].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h4, ex); + rs[4].assertNotInvoked(); + } + try { + assertNull(h5.join()); + rs[5].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h5, ex); + rs[5].assertNotInvoked(); + } - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - checkCompletedWithWrappedCancellationException(g); - } + checkCompletedWithWrappedCFException(f, ex); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCFException(h0, ex); + checkCompletedWithWrappedCFException(h1, ex); + checkCompletedWithWrappedCFException(h2, ex); + checkCompletedWithWrappedCFException(h3, ex); + checkCompletedWithWrappedCFException(h4, ex); + for (int i = 0; i < 4; i++) rs[i].assertNotInvoked(); + }} + + public void testRunAfterEither_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean fFirst : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final CFException ex = new CFException(); + final Noop[] rs = new Noop[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m); + + final CompletableFuture h0 = m.runAfterEither(f, g, rs[0]); + final CompletableFuture h1 = m.runAfterEither(g, f, rs[1]); + if (fFirst) { + f.complete(v1); + g.completeExceptionally(ex); + } else { + g.completeExceptionally(ex); + f.complete(v1); + } + final CompletableFuture h2 = m.runAfterEither(f, g, rs[2]); + final CompletableFuture h3 = m.runAfterEither(g, f, rs[3]); - /** - * acceptEitherAsync result completes normally after normal - * completion of sources - */ - public void testAcceptEitherAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); + // unspecified behavior - both source completions available + try { + assertEquals(null, h0.join()); + rs[0].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h0, ex); + rs[0].assertNotInvoked(); + } + try { + assertEquals(null, h1.join()); + rs[1].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h1, ex); + rs[1].assertNotInvoked(); + } + try { + assertEquals(null, h2.join()); + rs[2].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h2, ex); + rs[2].assertNotInvoked(); + } + try { + assertEquals(null, h3.join()); + rs[3].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h3, ex); + rs[3].assertNotInvoked(); + } - r = new IncAction(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - checkCompletedNormally(g, null); - assertEquals(r.value, 2); - } + checkCompletedNormally(f, v1); + checkCompletedWithWrappedCFException(g, ex); + }} /** - * acceptEitherAsync result completes exceptionally after exceptional - * completion of source + * runAfterEither result completes exceptionally if either source cancelled */ - public void testAcceptEitherAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + public void testRunAfterEither_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop[] rs = new Noop[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m); + + final CompletableFuture h0 = m.runAfterEither(f, g, rs[0]); + final CompletableFuture h1 = m.runAfterEither(g, f, rs[1]); + checkIncomplete(h0); + checkIncomplete(h1); + rs[0].assertNotInvoked(); + rs[1].assertNotInvoked(); + f.cancel(mayInterruptIfRunning); + checkCompletedWithWrappedCancellationException(h0); + checkCompletedWithWrappedCancellationException(h1); + final CompletableFuture h2 = m.runAfterEither(f, g, rs[2]); + final CompletableFuture h3 = m.runAfterEither(g, f, rs[3]); + checkCompletedWithWrappedCancellationException(h2); + checkCompletedWithWrappedCancellationException(h3); + + g.complete(v1); + + // unspecified behavior - both source completions available + final CompletableFuture h4 = m.runAfterEither(f, g, rs[4]); + final CompletableFuture h5 = m.runAfterEither(g, f, rs[5]); + try { + assertNull(h4.join()); + rs[4].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h4); + rs[4].assertNotInvoked(); + } + try { + assertNull(h5.join()); + rs[5].assertInvoked(); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h5); + rs[5].assertNotInvoked(); + } - r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + checkCancelled(f); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCancellationException(h0); + checkCompletedWithWrappedCancellationException(h1); + checkCompletedWithWrappedCancellationException(h2); + checkCompletedWithWrappedCancellationException(h3); + for (int i = 0; i < 4; i++) rs[i].assertNotInvoked(); + }} /** - * acceptEitherAsync result completes exceptionally if action does + * runAfterEither result completes exceptionally if action does */ - public void testAcceptEitherAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingConsumer r = new FailingConsumer(); - CompletableFuture g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testRunAfterEither_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + for (Integer v2 : new Integer[] { 2, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final FailingRunnable[] rs = new FailingRunnable[6]; + for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m); + + final CompletableFuture h0 = m.runAfterEither(f, g, rs[0]); + final CompletableFuture h1 = m.runAfterEither(g, f, rs[1]); + f.complete(v1); + final CompletableFuture h2 = m.runAfterEither(f, g, rs[2]); + final CompletableFuture h3 = m.runAfterEither(g, f, rs[3]); + checkCompletedWithWrappedCFException(h0); + checkCompletedWithWrappedCFException(h1); + checkCompletedWithWrappedCFException(h2); + checkCompletedWithWrappedCFException(h3); + for (int i = 0; i < 4; i++) rs[i].assertInvoked(); + g.complete(v2); + final CompletableFuture h4 = m.runAfterEither(f, g, rs[4]); + final CompletableFuture h5 = m.runAfterEither(g, f, rs[5]); + checkCompletedWithWrappedCFException(h4); + checkCompletedWithWrappedCFException(h5); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + for (int i = 0; i < 6; i++) rs[i].assertInvoked(); + }} /** - * acceptEitherAsync result completes exceptionally if either - * source cancelled - */ - public void testAcceptEitherAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - IncAction r = new IncAction(); - CompletableFuture g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - - r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * runAfterEitherAsync result completes normally after normal - * completion of sources + * thenCompose result completes normally after normal completion of source */ - public void testRunAfterEitherAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedNormally(g, null); - assertTrue(r.ran); - - r = new Noop(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - checkCompletedNormally(g, null); - assertTrue(r.ran); - } + public void testThenCompose_normalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFutureInc r = new CompletableFutureInc(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenCompose(f, r); + if (createIncomplete) f.complete(v1); + + checkCompletedNormally(g, inc(v1)); + checkCompletedNormally(f, v1); + r.assertValue(v1); + }} /** - * runAfterEitherAsync result completes exceptionally after exceptional + * thenCompose result completes exceptionally after exceptional * completion of source */ - public void testRunAfterEitherAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testThenCompose_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + { + final CFException ex = new CFException(); + final CompletableFutureInc r = new CompletableFutureInc(m); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = m.thenCompose(f, r); + if (createIncomplete) f.completeExceptionally(ex); + + checkCompletedWithWrappedCFException(g, ex); + checkCompletedWithWrappedCFException(f, ex); + r.assertNotInvoked(); + }} /** - * runAfterEitherAsync result completes exceptionally if action does - */ - public void testRunAfterEitherAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } - - /** - * runAfterEitherAsync result completes exceptionally if either - * source cancelled - */ - public void testRunAfterEitherAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * thenComposeAsync result completes normally after normal - * completion of source + * thenCompose result completes exceptionally if action does */ - public void testThenComposeAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); - f.complete(one); - checkCompletedNormally(g, two); - } + public void testThenCompose_actionFailed() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final CompletableFuture f = new CompletableFuture<>(); + final FailingCompletableFutureFunction r + = new FailingCompletableFutureFunction(m); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.thenCompose(f, r); + if (createIncomplete) f.complete(v1); - /** - * thenComposeAsync result completes exceptionally after - * exceptional completion of source - */ - public void testThenComposeAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); - f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); - } + checkCompletedNormally(f, v1); + }} /** - * thenComposeAsync result completes exceptionally if action does + * thenCompose result completes exceptionally if source cancelled */ - public void testThenComposeAsync3E() { - CompletableFuture f = new CompletableFuture(); - FailingCompletableFutureFunction r = new FailingCompletableFutureFunction(); - CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); - f.complete(one); - checkCompletedWithWrappedCFException(g); - } + public void testThenCompose_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + { + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFutureInc r = new CompletableFutureInc(m); + if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); + final CompletableFuture g = m.thenCompose(f, r); + if (createIncomplete) { + checkIncomplete(g); + assertTrue(f.cancel(mayInterruptIfRunning)); + } - /** - * thenComposeAsync result completes exceptionally if source cancelled - */ - public void testThenComposeAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFutureInc r = new CompletableFutureInc(); - CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); - assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); - } + checkCancelled(f); + }} // other static methods @@ -2340,24 +2601,45 @@ public class CompletableFutureTest exten * with the value null */ public void testAllOf_empty() throws Exception { - CompletableFuture f = CompletableFuture.allOf(); + CompletableFuture f = CompletableFuture.allOf(); checkCompletedNormally(f, null); } /** - * allOf returns a future completed when all components complete + * allOf returns a future completed normally with the value null + * when all components complete normally */ - public void testAllOf() throws Exception { + public void testAllOf_normal() throws Exception { for (int k = 1; k < 20; ++k) { - CompletableFuture[] fs = new CompletableFuture[k]; + CompletableFuture[] fs + = (CompletableFuture[]) new CompletableFuture[k]; for (int i = 0; i < k; ++i) - fs[i] = new CompletableFuture(); + fs[i] = new CompletableFuture<>(); CompletableFuture f = CompletableFuture.allOf(fs); for (int i = 0; i < k; ++i) { checkIncomplete(f); + checkIncomplete(CompletableFuture.allOf(fs)); + fs[i].complete(one); + } + checkCompletedNormally(f, null); + checkCompletedNormally(CompletableFuture.allOf(fs), null); + } + } + + public void testAllOf_backwards() throws Exception { + for (int k = 1; k < 20; ++k) { + CompletableFuture[] fs + = (CompletableFuture[]) new CompletableFuture[k]; + for (int i = 0; i < k; ++i) + fs[i] = new CompletableFuture<>(); + CompletableFuture f = CompletableFuture.allOf(fs); + for (int i = k - 1; i >= 0; i--) { + checkIncomplete(f); + checkIncomplete(CompletableFuture.allOf(fs)); fs[i].complete(one); } checkCompletedNormally(f, null); + checkCompletedNormally(CompletableFuture.allOf(fs), null); } } @@ -2365,23 +2647,43 @@ public class CompletableFutureTest exten * anyOf(no component futures) returns an incomplete future */ public void testAnyOf_empty() throws Exception { - CompletableFuture f = CompletableFuture.anyOf(); + CompletableFuture f = CompletableFuture.anyOf(); checkIncomplete(f); } /** - * allOf returns a future completed when any components complete + * anyOf returns a future completed normally with a value when + * a component future does */ - public void testAnyOf() throws Exception { - for (int k = 1; k < 20; ++k) { + public void testAnyOf_normal() throws Exception { + for (int k = 0; k < 10; ++k) { CompletableFuture[] fs = new CompletableFuture[k]; for (int i = 0; i < k; ++i) - fs[i] = new CompletableFuture(); + fs[i] = new CompletableFuture<>(); CompletableFuture f = CompletableFuture.anyOf(fs); checkIncomplete(f); for (int i = 0; i < k; ++i) { fs[i].complete(one); checkCompletedNormally(f, one); + checkCompletedNormally(CompletableFuture.anyOf(fs), one); + } + } + } + + /** + * anyOf result completes exceptionally when any component does. + */ + public void testAnyOf_exceptional() throws Exception { + for (int k = 0; k < 10; ++k) { + CompletableFuture[] fs = new CompletableFuture[k]; + for (int i = 0; i < k; ++i) + fs[i] = new CompletableFuture<>(); + CompletableFuture f = CompletableFuture.anyOf(fs); + checkIncomplete(f); + for (int i = 0; i < k; ++i) { + fs[i].completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs)); } } } @@ -2390,44 +2692,255 @@ public class CompletableFutureTest exten * Completion methods throw NullPointerException with null arguments */ public void testNPE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = new CompletableFuture(); - CompletableFuture h; - Runnable[] actions = { - () => f.thenApply(null), - } - try { h = f.thenApply(null); } catch (NullPointerException ok) {} - try { h = f.thenAccept(null); } catch (NullPointerException ok) {} - try { h = f.thenRun(null); } catch (NullPointerException ok) {} - try { h = f.thenCombine(g, null); } catch (NullPointerException ok) {} - try { h = f.thenCombine(null, null); } catch (NullPointerException ok) {} - try { h = f.applyToEither(g, null); } catch (NullPointerException ok) {} - try { h = f.applyToEither(null, null); } catch (NullPointerException ok) {} - try { h = f.thenAcceptBoth(g, null); } catch (NullPointerException ok) {} - try { h = f.thenAcceptBoth(null, null); } catch (NullPointerException ok) {} - try { h = f.runAfterEither(g, null); } catch (NullPointerException ok) {} - try { h = f.runAfterEither(null, null); } catch (NullPointerException ok) {} - try { h = f.runAfterBoth(g, null); } catch (NullPointerException ok) {} - try { h = f.runAfterBoth(null, null); } catch (NullPointerException ok) {} - try { h = f.exceptionally(null); } catch (NullPointerException ok) {} - try { h = f.handle(null); } catch (NullPointerException ok) {} - try { h = f.thenCompose(null); } catch (NullPointerException ok) {} - - try { h = f.thenApplyAsync(null); } catch (NullPointerException ok) {} - try { h = f.thenAcceptAsync(null); } catch (NullPointerException ok) {} - try { h = f.thenRunAsync(null); } catch (NullPointerException ok) {} - try { h = f.thenCombineAsync(g, null); } catch (NullPointerException ok) {} - try { h = f.thenCombineAsync(null, null); } catch (NullPointerException ok) {} - try { h = f.applyToEitherAsync(g, null); } catch (NullPointerException ok) {} - try { h = f.applyToEitherAsync(null, null); } catch (NullPointerException ok) {} - try { h = f.thenAcceptBothAsync(g, null); } catch (NullPointerException ok) {} - try { h = f.thenAcceptBothAsync(null, null); } catch (NullPointerException ok) {} - try { h = f.runAfterEitherAsync(g, null); } catch (NullPointerException ok) {} - try { h = f.runAfterEitherAsync(null, null); } catch (NullPointerException ok) {} - try { h = f.runAfterBothAsync(g, null); } catch (NullPointerException ok) {} - try { h = f.runAfterBothAsync(null, null); } catch (NullPointerException ok) {} + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = new CompletableFuture<>(); + CompletableFuture nullFuture = (CompletableFuture)null; + CompletableFuture h; + ThreadExecutor exec = new ThreadExecutor(); + + Runnable[] throwingActions = { + () -> CompletableFuture.supplyAsync(null), + () -> CompletableFuture.supplyAsync(null, exec), + () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null), + + () -> CompletableFuture.runAsync(null), + () -> CompletableFuture.runAsync(null, exec), + () -> CompletableFuture.runAsync(() -> {}, null), + + () -> f.completeExceptionally(null), + + () -> f.thenApply(null), + () -> f.thenApplyAsync(null), + () -> f.thenApplyAsync((x) -> x, null), + () -> f.thenApplyAsync(null, exec), + + () -> f.thenAccept(null), + () -> f.thenAcceptAsync(null), + () -> f.thenAcceptAsync((x) -> {} , null), + () -> f.thenAcceptAsync(null, exec), + + () -> f.thenRun(null), + () -> f.thenRunAsync(null), + () -> f.thenRunAsync(() -> {} , null), + () -> f.thenRunAsync(null, exec), + + () -> f.thenCombine(g, null), + () -> f.thenCombineAsync(g, null), + () -> f.thenCombineAsync(g, null, exec), + () -> f.thenCombine(nullFuture, (x, y) -> x), + () -> f.thenCombineAsync(nullFuture, (x, y) -> x), + () -> f.thenCombineAsync(nullFuture, (x, y) -> x, exec), + () -> f.thenCombineAsync(g, (x, y) -> x, null), + + () -> f.thenAcceptBoth(g, null), + () -> f.thenAcceptBothAsync(g, null), + () -> f.thenAcceptBothAsync(g, null, exec), + () -> f.thenAcceptBoth(nullFuture, (x, y) -> {}), + () -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}), + () -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec), + () -> f.thenAcceptBothAsync(g, (x, y) -> {}, null), + + () -> f.runAfterBoth(g, null), + () -> f.runAfterBothAsync(g, null), + () -> f.runAfterBothAsync(g, null, exec), + () -> f.runAfterBoth(nullFuture, () -> {}), + () -> f.runAfterBothAsync(nullFuture, () -> {}), + () -> f.runAfterBothAsync(nullFuture, () -> {}, exec), + () -> f.runAfterBothAsync(g, () -> {}, null), + + () -> f.applyToEither(g, null), + () -> f.applyToEitherAsync(g, null), + () -> f.applyToEitherAsync(g, null, exec), + () -> f.applyToEither(nullFuture, (x) -> x), + () -> f.applyToEitherAsync(nullFuture, (x) -> x), + () -> f.applyToEitherAsync(nullFuture, (x) -> x, exec), + () -> f.applyToEitherAsync(g, (x) -> x, null), + + () -> f.acceptEither(g, null), + () -> f.acceptEitherAsync(g, null), + () -> f.acceptEitherAsync(g, null, exec), + () -> f.acceptEither(nullFuture, (x) -> {}), + () -> f.acceptEitherAsync(nullFuture, (x) -> {}), + () -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec), + () -> f.acceptEitherAsync(g, (x) -> {}, null), + + () -> f.runAfterEither(g, null), + () -> f.runAfterEitherAsync(g, null), + () -> f.runAfterEitherAsync(g, null, exec), + () -> f.runAfterEither(nullFuture, () -> {}), + () -> f.runAfterEitherAsync(nullFuture, () -> {}), + () -> f.runAfterEitherAsync(nullFuture, () -> {}, exec), + () -> f.runAfterEitherAsync(g, () -> {}, null), + + () -> f.thenCompose(null), + () -> f.thenComposeAsync(null), + () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null), + () -> f.thenComposeAsync(null, exec), + + () -> f.exceptionally(null), + + () -> f.handle(null), + + () -> CompletableFuture.allOf((CompletableFuture)null), + () -> CompletableFuture.allOf((CompletableFuture[])null), + () -> CompletableFuture.allOf(f, null), + () -> CompletableFuture.allOf(null, f), + + () -> CompletableFuture.anyOf((CompletableFuture)null), + () -> CompletableFuture.anyOf((CompletableFuture[])null), + () -> CompletableFuture.anyOf(f, null), + () -> CompletableFuture.anyOf(null, f), + + () -> f.obtrudeException(null), + }; + + assertThrows(NullPointerException.class, throwingActions); + assertEquals(0, exec.count.get()); + } + + /** + * toCompletableFuture returns this CompletableFuture. + */ + public void testToCompletableFuture() { + CompletableFuture f = new CompletableFuture<>(); + assertSame(f, f.toCompletableFuture()); + } + + /** + * whenComplete action executes on normal completion, propagating + * source result. + */ + public void testWhenComplete_normalCompletion1() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.whenComplete + (f, + (Integer x, Throwable t) -> { + threadAssertSame(x, v1); + threadAssertNull(t); + a.getAndIncrement(); + }); + if (createIncomplete) f.complete(v1); + + checkCompletedNormally(g, v1); + checkCompletedNormally(f, v1); + assertEquals(1, a.get()); + }} + + /** + * whenComplete action executes on exceptional completion, propagating + * source result. + */ + public void testWhenComplete_exceptionalCompletion() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean createIncomplete : new boolean[] { true, false }) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.completeExceptionally(ex); + final CompletableFuture g = m.whenComplete + (f, + (Integer x, Throwable t) -> { + threadAssertNull(x); + threadAssertSame(t, ex); + a.getAndIncrement(); + }); + if (createIncomplete) f.completeExceptionally(ex); + checkCompletedWithWrappedCFException(f, ex); + checkCompletedWithWrappedCFException(g, ex); + assertEquals(1, a.get()); + }} + + /** + * whenComplete action executes on cancelled source, propagating + * CancellationException. + */ + public void testWhenComplete_sourceCancelled() { + for (ExecutionMode m : ExecutionMode.values()) + for (boolean mayInterruptIfRunning : new boolean[] { true, false }) + for (boolean createIncomplete : new boolean[] { true, false }) + { + final AtomicInteger a = new AtomicInteger(0); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); + final CompletableFuture g = m.whenComplete + (f, + (Integer x, Throwable t) -> { + threadAssertNull(x); + threadAssertTrue(t instanceof CancellationException); + a.getAndIncrement(); + }); + if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning)); - } + //try { g.join(); } catch (Throwable t) { throw new Error(t); } + checkCompletedWithWrappedCancellationException(g); + checkCancelled(f); + assertEquals(1, a.get()); + }} + /** + * If a whenComplete action throws an exception when triggered by + * a normal completion, it completes exceptionally + */ + public void testWhenComplete_actionFailed() { + for (boolean createIncomplete : new boolean[] { true, false }) + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CFException ex = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + if (!createIncomplete) f.complete(v1); + final CompletableFuture g = m.whenComplete + (f, + (Integer x, Throwable t) -> { + threadAssertSame(x, v1); + threadAssertNull(t); + a.getAndIncrement(); + throw ex; + }); + if (createIncomplete) f.complete(v1); + checkCompletedNormally(f, v1); + checkCompletedWithWrappedCFException(g, ex); + assertEquals(1, a.get()); + }} + + /** + * If a whenComplete action throws an exception when triggered by + * a source completion that also throws an exception, the source + * exception takes precedence. + */ + public void testWhenComplete_actionFailedSourceFailed() { + for (boolean createIncomplete : new boolean[] { true, false }) + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) + { + final AtomicInteger a = new AtomicInteger(0); + final CFException ex1 = new CFException(); + final CFException ex2 = new CFException(); + final CompletableFuture f = new CompletableFuture<>(); + + if (!createIncomplete) f.completeExceptionally(ex1); + final CompletableFuture g = m.whenComplete + (f, + (Integer x, Throwable t) -> { + threadAssertSame(t, ex1); + threadAssertNull(x); + a.getAndIncrement(); + throw ex2; + }); + if (createIncomplete) f.completeExceptionally(ex1); + + checkCompletedWithWrappedCFException(f, ex1); + checkCompletedWithWrappedCFException(g, ex1); + assertEquals(1, a.get()); + }} }