--- jsr166/src/test/tck/CompletableFutureTest.java 2013/04/08 16:58:17 1.21 +++ jsr166/src/test/tck/CompletableFutureTest.java 2014/06/02 00:46:52 1.39 @@ -16,6 +16,7 @@ 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.TimeoutException; import java.util.concurrent.atomic.AtomicInteger; import static java.util.concurrent.TimeUnit.MILLISECONDS; @@ -68,6 +69,7 @@ public class CompletableFutureTest exten } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); assertFalse(f.isCancelled()); + assertFalse(f.isCompletedExceptionally()); assertTrue(f.toString().contains("[Completed normally]")); } @@ -101,6 +103,37 @@ public class CompletableFutureTest exten assertTrue(f.toString().contains("[Completed exceptionally]")); } + void checkCompletedWithWrappedCFException(CompletableFuture f, + CFException ex) { + try { + f.get(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + 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); @@ -121,6 +154,7 @@ public class CompletableFutureTest exten } catch (CancellationException success) { } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); + assertTrue(f.isCompletedExceptionally()); assertTrue(f.isCancelled()); assertTrue(f.toString().contains("[Completed exceptionally]")); } @@ -152,6 +186,7 @@ public class CompletableFutureTest exten } catch (Throwable fail) { threadUnexpectedException(fail); } assertTrue(f.isDone()); assertFalse(f.isCancelled()); + assertTrue(f.isCompletedExceptionally()); assertTrue(f.toString().contains("[Completed exceptionally]")); } @@ -160,7 +195,7 @@ public class CompletableFutureTest exten * by methods isDone, isCancelled, and getNow */ public void testConstructor() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); checkIncomplete(f); } @@ -169,7 +204,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); @@ -180,7 +215,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); @@ -191,7 +226,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); @@ -201,7 +236,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); @@ -209,10 +244,10 @@ 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 = new CompletableFuture<>(); f.completeExceptionally(new CFException()); f.obtrudeValue(four); checkCompletedNormally(f, four); @@ -222,16 +257,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); @@ -243,7 +278,7 @@ public class CompletableFutureTest exten * getNumberOfDependents returns number of dependent tasks */ public void testGetNumberOfDependents() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); assertEquals(f.getNumberOfDependents(), 0); CompletableFuture g = f.thenRun(new Noop()); assertEquals(f.getNumberOfDependents(), 1); @@ -256,7 +291,6 @@ public class CompletableFutureTest exten assertEquals(g.getNumberOfDependents(), 0); } - /** * toString indicates current completion state */ @@ -284,20 +318,60 @@ public class CompletableFutureTest exten // 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()); + } + + // A function that handles and produces null values as well. + static Integer inc(Integer x) { + return (x == null) ? null : x + 1; + } + static final Supplier supplyOne = () -> Integer.valueOf(1); static final Function inc = (Integer x) -> Integer.valueOf(x.intValue() + 1); static final BiFunction subtract = - (Integer x, Integer y) -> Integer.valueOf(x.intValue() - y.intValue()); + (Integer x, Integer y) -> subtract(x, y); static final class IncAction implements Consumer { - int value; - public void accept(Integer x) { value = x.intValue() + 1; } + int invocationCount = 0; + Integer value; + public boolean ran() { return invocationCount == 1; } + public void accept(Integer x) { + invocationCount++; + value = inc(x); + } + } + static final class IncFunction implements Function { + int invocationCount = 0; + Integer value; + public boolean ran() { return invocationCount == 1; } + public Integer apply(Integer x) { + invocationCount++; + return value = inc(x); + } } - static final class AddAction implements BiConsumer { - int value; + static final class SubtractAction implements BiConsumer { + int invocationCount = 0; + Integer value; + // Check this action was invoked exactly once when result is computed. + public boolean ran() { return invocationCount == 1; } public void accept(Integer x, Integer y) { - value = x.intValue() + y.intValue(); + invocationCount++; + value = subtract(x, y); + } + } + static final class SubtractFunction implements BiFunction { + int invocationCount = 0; + Integer value; + // Check this action was invoked exactly once when result is computed. + public boolean ran() { return invocationCount == 1; } + public Integer apply(Integer x, Integer y) { + invocationCount++; + return value = subtract(x, y); } } static final class Noop implements Runnable { @@ -335,7 +409,7 @@ public class CompletableFutureTest exten boolean ran; public CompletableFuture apply(Integer x) { ran = true; - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); f.complete(Integer.valueOf(x.intValue() + 1)); return f; } @@ -371,19 +445,223 @@ public class CompletableFutureTest exten } } + /** + * Permits the testing of parallel code for the 3 different + * execution modes without repeating all the testing code. + */ + enum ExecutionMode { + DEFAULT { + 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 applyToEither + (CompletableFuture f, + CompletionStage g, + Function a) { + return f.applyToEither(g, a); + } + public CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a) { + return f.acceptEither(g, a); + } + public CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a) { + return f.runAfterEither(g, a); + } + public CompletableFuture thenCompose + (CompletableFuture f, + Function> a) { + return f.thenCompose(a); + } + public CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a) { + return f.whenComplete(a); + } + }, + +// /** Experimental way to do more testing */ +// REVERSE_DEFAULT { +// public CompletableFuture runAfterBoth +// (CompletableFuture f, CompletableFuture g, Runnable a) { +// return g.runAfterBoth(f, a); +// } +// public CompletableFuture thenAcceptBoth +// (CompletableFuture f, +// CompletionStage g, +// BiConsumer a) { +// return DEFAULT.thenAcceptBoth(f, g, a); +// } +// }, + + DEFAULT_ASYNC { + 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 applyToEither + (CompletableFuture f, + CompletionStage g, + Function a) { + return f.applyToEitherAsync(g, a); + } + public CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a) { + return f.acceptEitherAsync(g, a); + } + public CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a) { + return f.runAfterEitherAsync(g, a); + } + public CompletableFuture thenCompose + (CompletableFuture f, + Function> a) { + return f.thenComposeAsync(a); + } + public CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a) { + return f.whenCompleteAsync(a); + } + }, + +// REVERSE_DEFAULT_ASYNC { +// public CompletableFuture runAfterBoth +// (CompletableFuture f, CompletableFuture g, Runnable a) { +// return f.runAfterBothAsync(g, a); +// } +// public CompletableFuture thenAcceptBoth +// (CompletableFuture f, +// CompletionStage g, +// BiConsumer a) { +// return DEFAULT_ASYNC.thenAcceptBoth(f, g, a); +// } +// }, + + EXECUTOR { + 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 applyToEither + (CompletableFuture f, + CompletionStage g, + Function a) { + return f.applyToEitherAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a) { + return f.acceptEitherAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a) { + return f.runAfterEitherAsync(g, a, new ThreadExecutor()); + } + public CompletableFuture thenCompose + (CompletableFuture f, + Function> a) { + return f.thenComposeAsync(a, new ThreadExecutor()); + } + public CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a) { + return f.whenCompleteAsync(a, new ThreadExecutor()); + } + }; + + 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 applyToEither + (CompletableFuture f, + CompletionStage g, + Function a); + public abstract CompletableFuture acceptEither + (CompletableFuture f, + CompletionStage g, + Consumer a); + public abstract CompletableFuture runAfterEither + (CompletableFuture f, + CompletionStage g, + java.lang.Runnable a); + public abstract CompletableFuture thenCompose + (CompletableFuture f, + Function> a); + public abstract CompletableFuture whenComplete + (CompletableFuture f, + BiConsumer a); + + + } /** * exceptionally action completes with function value on source - * exception; otherwise with source value + * exception; otherwise with source value */ public void testExceptionally() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); ExceptionToInteger r = new ExceptionToInteger(); CompletableFuture g = f.exceptionally(r); f.completeExceptionally(new CFException()); checkCompletedNormally(g, three); - f = new CompletableFuture(); + f = new CompletableFuture<>(); r = new ExceptionToInteger(); g = f.exceptionally(r); f.complete(one); @@ -398,26 +676,26 @@ public class CompletableFutureTest exten CompletableFuture f, g; IntegerHandler r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.completeExceptionally(new CFException()); g = f.handle(r = new IntegerHandler()); assertTrue(r.ran); checkCompletedNormally(g, three); - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.handle(r = new IntegerHandler()); assertFalse(r.ran); f.completeExceptionally(new CFException()); checkCompletedNormally(g, three); assertTrue(r.ran); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); g = f.handle(r = new IntegerHandler()); assertTrue(r.ran); checkCompletedNormally(g, two); - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.handle(r = new IntegerHandler()); assertFalse(r.ran); f.complete(one); @@ -495,17 +773,21 @@ public class CompletableFutureTest exten * 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); + CompletableFuture f; + CompletableFuture g; + Noop r; + + f = new CompletableFuture<>(); + g = f.thenRun(r = new Noop()); f.complete(null); checkCompletedNormally(g, null); - // reordered version - f = new CompletableFuture(); + assertTrue(r.ran); + + f = new CompletableFuture<>(); f.complete(null); - r = new Noop(); - g = f.thenRun(r); + g = f.thenRun(r = new Noop()); checkCompletedNormally(g, null); + assertTrue(r.ran); } /** @@ -513,32 +795,58 @@ public class CompletableFutureTest exten * completion of source */ public void testThenRun2() { - CompletableFuture f = new CompletableFuture(); - Noop r = new Noop(); - CompletableFuture g = f.thenRun(r); + CompletableFuture f; + CompletableFuture g; + Noop r; + + f = new CompletableFuture<>(); + g = f.thenRun(r = new Noop()); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(g); + assertFalse(r.ran); + + f = new CompletableFuture<>(); f.completeExceptionally(new CFException()); + g = f.thenRun(r = new Noop()); checkCompletedWithWrappedCFException(g); + assertFalse(r.ran); } /** * thenRun result completes exceptionally if action does */ public void testThenRun3() { - CompletableFuture f = new CompletableFuture(); - FailingNoop r = new FailingNoop(); - CompletableFuture g = f.thenRun(r); + CompletableFuture f; + CompletableFuture g; + FailingNoop r; + + f = new CompletableFuture<>(); + g = f.thenRun(r = new FailingNoop()); f.complete(null); checkCompletedWithWrappedCFException(g); + + f = new CompletableFuture<>(); + f.complete(null); + g = f.thenRun(r = new FailingNoop()); + 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); + CompletableFuture f; + CompletableFuture g; + Noop r; + + f = new CompletableFuture<>(); + g = f.thenRun(r = new Noop()); + assertTrue(f.cancel(true)); + checkCompletedWithWrappedCancellationException(g); + + f = new CompletableFuture<>(); assertTrue(f.cancel(true)); + g = f.thenRun(r = new Noop()); checkCompletedWithWrappedCancellationException(g); } @@ -546,7 +854,7 @@ public class CompletableFutureTest exten * thenApply result completes normally after normal completion of source */ public void testThenApply() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApply(inc); f.complete(one); checkCompletedNormally(g, two); @@ -557,7 +865,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenApply2() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApply(inc); f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); @@ -567,7 +875,7 @@ public class CompletableFutureTest exten * thenApply result completes exceptionally if action does */ public void testThenApply3() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApply(new FailingFunction()); f.complete(one); checkCompletedWithWrappedCFException(g); @@ -577,7 +885,7 @@ public class CompletableFutureTest exten * thenApply result completes exceptionally if source cancelled */ public void testThenApply4() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApply(inc); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); @@ -587,12 +895,12 @@ public class CompletableFutureTest exten * thenAccept result completes normally after normal completion of source */ public void testThenAccept() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAccept(r); f.complete(one); checkCompletedNormally(g, null); - assertEquals(r.value, 2); + assertEquals(r.value, (Integer) 2); } /** @@ -600,7 +908,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenAccept2() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAccept(r); f.completeExceptionally(new CFException()); @@ -611,7 +919,7 @@ public class CompletableFutureTest exten * thenAccept result completes exceptionally if action does */ public void testThenAccept3() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingConsumer r = new FailingConsumer(); CompletableFuture g = f.thenAccept(r); f.complete(one); @@ -623,357 +931,1221 @@ public class CompletableFutureTest exten * thenAccept result completes exceptionally if source cancelled */ public void testThenAccept4() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAccept(r); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); } - /** * thenCombine result completes normally after normal completion * of sources */ - public void testThenCombine() { - CompletableFuture f, g, h; + public void testThenCombine_normalCompletion1() { + 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 SubtractFunction r = new SubtractFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); + + f.complete(v1); + checkIncomplete(h); + assertFalse(r.ran()); + g.complete(v2); + + checkCompletedNormally(h, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenCombine_normalCompletion2() { + 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 SubtractFunction r = new SubtractFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); + + g.complete(v2); + checkIncomplete(h); + assertFalse(r.ran()); + f.complete(v1); + + checkCompletedNormally(h, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombine(g, subtract); - f.complete(3); - checkIncomplete(h); - g.complete(1); - checkCompletedNormally(h, 2); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombine(g, subtract); - g.complete(1); - checkIncomplete(h); - f.complete(3); - checkCompletedNormally(h, 2); - - f = new CompletableFuture(); - g = new CompletableFuture(); - g.complete(1); - f.complete(3); - h = f.thenCombine(g, subtract); - checkCompletedNormally(h, 2); + public void testThenCombine_normalCompletion3() { + 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 SubtractFunction r = new SubtractFunction(); + + g.complete(v2); + f.complete(v1); + final CompletableFuture h = m.thenCombine(f, g, r); + + checkCompletedNormally(h, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenCombine_normalCompletion4() { + 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 SubtractFunction r = new SubtractFunction(); + + f.complete(v1); + g.complete(v2); + final CompletableFuture h = m.thenCombine(f, g, r); + + checkCompletedNormally(h, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * thenCombine result completes exceptionally after exceptional * completion of either source */ - public void testThenCombine2() { - CompletableFuture f, g, h; + public void testThenCombine_exceptionalCompletion1() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractFunction r = new SubtractFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); + final CFException ex = new CFException(); - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombine(g, subtract); - f.completeExceptionally(new CFException()); + f.completeExceptionally(ex); checkIncomplete(h); - g.complete(1); - checkCompletedWithWrappedCFException(h); + g.complete(v1); - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombine(g, subtract); - g.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } + } + + public void testThenCombine_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractFunction r = new SubtractFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCFException(h); + f.complete(v1); - f = new CompletableFuture(); - g = new CompletableFuture(); - f.complete(3); - g.completeExceptionally(new CFException()); - h = f.thenCombine(g, subtract); - checkCompletedWithWrappedCFException(h); + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(g, ex); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } - f = new CompletableFuture(); - g = new CompletableFuture(); - f.completeExceptionally(new CFException()); - g.complete(3); - h = f.thenCombine(g, subtract); - checkCompletedWithWrappedCFException(h); + public void testThenCombine_exceptionalCompletion3() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractFunction r = new SubtractFunction(); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + f.complete(v1); + final CompletableFuture h = m.thenCombine(f, g, r); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(g, ex); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenCombine_exceptionalCompletion4() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractFunction r = new SubtractFunction(); + final CFException ex = new CFException(); + + f.completeExceptionally(ex); + g.complete(v1); + final CompletableFuture h = m.thenCombine(f, g, r); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } } /** * 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); - assertFalse(r.ran); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - assertTrue(r.ran); + public void testThenCombine_actionFailed1() { + 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 FailingBiFunction r = new FailingBiFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); + + f.complete(v1); + checkIncomplete(h); + g.complete(v2); + + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenCombine_actionFailed2() { + 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 FailingBiFunction r = new FailingBiFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); + + g.complete(v2); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * thenCombine result completes exceptionally if either source cancelled */ - public void testThenCombine4() { - CompletableFuture f, g, h; + public void testThenCombine_sourceCancelled1() { + 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 SubtractFunction r = new SubtractFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombine(g, subtract); - assertTrue(f.cancel(true)); + assertTrue(f.cancel(mayInterruptIfRunning)); checkIncomplete(h); - g.complete(1); + g.complete(v1); + checkCompletedWithWrappedCancellationException(h); + checkCancelled(f); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } + } + + public void testThenCombine_sourceCancelled2() { + 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 SubtractFunction r = new SubtractFunction(); + final CompletableFuture h = m.thenCombine(f, g, r); - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombine(g, subtract); - assertTrue(g.cancel(true)); + assertTrue(g.cancel(mayInterruptIfRunning)); checkIncomplete(h); - f.complete(3); + f.complete(v1); + checkCompletedWithWrappedCancellationException(h); + checkCancelled(g); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenCombine_sourceCancelled3() { + 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 SubtractFunction r = new SubtractFunction(); + + assertTrue(g.cancel(mayInterruptIfRunning)); + f.complete(v1); + final CompletableFuture h = m.thenCombine(f, g, r); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(g); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenCombine_sourceCancelled4() { + 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 SubtractFunction r = new SubtractFunction(); + + assertTrue(f.cancel(mayInterruptIfRunning)); + g.complete(v1); + final CompletableFuture h = m.thenCombine(f, g, r); - f = new CompletableFuture(); - g = new CompletableFuture(); - assertTrue(f.cancel(true)); - assertTrue(g.cancel(true)); - h = f.thenCombine(g, subtract); checkCompletedWithWrappedCancellationException(h); + checkCancelled(f); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } } /** * 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); + public void testThenAcceptBoth_normalCompletion1() { + 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 SubtractAction r = new SubtractAction(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); - 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); + f.complete(v1); + checkIncomplete(h); + assertFalse(r.ran()); + g.complete(v2); + + checkCompletedNormally(h, null); + assertEquals(r.value, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenAcceptBoth_normalCompletion2() { + 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 SubtractAction r = new SubtractAction(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + g.complete(v2); + checkIncomplete(h); + assertFalse(r.ran()); + f.complete(v1); + + checkCompletedNormally(h, null); + assertEquals(r.value, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenAcceptBoth_normalCompletion3() { + 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 SubtractAction r = new SubtractAction(); + + g.complete(v2); + f.complete(v1); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + checkCompletedNormally(h, null); + assertEquals(r.value, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenAcceptBoth_normalCompletion4() { + 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 SubtractAction r = new SubtractAction(); + + f.complete(v1); + g.complete(v2); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + checkCompletedNormally(h, null); + assertEquals(r.value, subtract(v1, v2)); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * 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); + public void testThenAcceptBoth_exceptionalCompletion1() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractAction r = new SubtractAction(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + final CFException ex = new CFException(); - r = new AddAction(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.thenAcceptBoth(f2, r); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + f.completeExceptionally(ex); + checkIncomplete(h); + g.complete(v1); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } + } + + public void testThenAcceptBoth_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractAction r = new SubtractAction(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(g, ex); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenAcceptBoth_exceptionalCompletion3() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractAction r = new SubtractAction(); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + f.complete(v1); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(g, ex); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenAcceptBoth_exceptionalCompletion4() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final SubtractAction r = new SubtractAction(); + final CFException ex = new CFException(); + + f.completeExceptionally(ex); + g.complete(v1); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } } /** * 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); + public void testThenAcceptBoth_actionFailed1() { + 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 FailingBiConsumer r = new FailingBiConsumer(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + f.complete(v1); + checkIncomplete(h); + g.complete(v2); + + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testThenAcceptBoth_actionFailed2() { + 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 FailingBiConsumer r = new FailingBiConsumer(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + g.complete(v2); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * 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 testThenAcceptBoth_sourceCancelled1() { + 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 SubtractAction r = new SubtractAction(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + assertTrue(f.cancel(mayInterruptIfRunning)); + checkIncomplete(h); + g.complete(v1); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(f); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } + } + + public void testThenAcceptBoth_sourceCancelled2() { + 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 SubtractAction r = new SubtractAction(); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + assertTrue(g.cancel(mayInterruptIfRunning)); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(g); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenAcceptBoth_sourceCancelled3() { + 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 SubtractAction r = new SubtractAction(); + + assertTrue(g.cancel(mayInterruptIfRunning)); + f.complete(v1); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(g); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + } + } + + public void testThenAcceptBoth_sourceCancelled4() { + 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 SubtractAction r = new SubtractAction(); + + assertTrue(f.cancel(mayInterruptIfRunning)); + g.complete(v1); + final CompletableFuture h = m.thenAcceptBoth(f, g, r); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(f); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } } /** * runAfterBoth result completes normally after normal * completion of sources */ - 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); + public void testRunAfterBoth_normalCompletion1() { + 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 r = new Noop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + f.complete(v1); + checkIncomplete(h); + assertFalse(r.ran); + g.complete(v2); + + checkCompletedNormally(h, null); assertTrue(r.ran); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } - 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); + public void testRunAfterBoth_normalCompletion2() { + 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 r = new Noop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + g.complete(v2); + checkIncomplete(h); + assertFalse(r.ran); + f.complete(v1); + + checkCompletedNormally(h, null); assertTrue(r.ran); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testRunAfterBoth_normalCompletion3() { + 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 r = new Noop(); + + g.complete(v2); + f.complete(v1); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + checkCompletedNormally(h, null); + assertTrue(r.ran); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testRunAfterBoth_normalCompletion4() { + 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 r = new Noop(); + + f.complete(v1); + g.complete(v2); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + checkCompletedNormally(h, null); + assertTrue(r.ran); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * 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); + public void testRunAfterBoth_exceptionalCompletion1() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop r = new Noop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + final CFException ex = new CFException(); - r = new Noop(); - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.runAfterBoth(f2, r); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); + f.completeExceptionally(ex); + checkIncomplete(h); + g.complete(v1); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran); + checkCompletedNormally(g, v1); + } + } + + public void testRunAfterBoth_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop r = new Noop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(g, ex); + assertFalse(r.ran); + checkCompletedNormally(f, v1); + } + } + + public void testRunAfterBoth_exceptionalCompletion3() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop r = new Noop(); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + f.complete(v1); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(g, ex); + assertFalse(r.ran); + checkCompletedNormally(f, v1); + } + } + + public void testRunAfterBoth_exceptionalCompletion4() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final Noop r = new Noop(); + final CFException ex = new CFException(); + + f.completeExceptionally(ex); + g.complete(v1); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + checkCompletedWithWrappedCFException(h, ex); + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran); + checkCompletedNormally(g, v1); + } } /** * 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 void testRunAfterBoth_actionFailed1() { + 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 FailingNoop r = new FailingNoop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + f.complete(v1); + checkIncomplete(h); + g.complete(v2); + + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testRunAfterBoth_actionFailed2() { + 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 FailingNoop r = new FailingNoop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + g.complete(v2); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCFException(h); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * 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); + public void testRunAfterBoth_sourceCancelled1() { + 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 r = new Noop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + assertTrue(f.cancel(mayInterruptIfRunning)); + checkIncomplete(h); + g.complete(v1); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(f); + assertFalse(r.ran); + checkCompletedNormally(g, v1); + } + } + + public void testRunAfterBoth_sourceCancelled2() { + 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 r = new Noop(); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + assertTrue(g.cancel(mayInterruptIfRunning)); + checkIncomplete(h); + f.complete(v1); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(g); + assertFalse(r.ran); + checkCompletedNormally(f, v1); + } + } + + public void testRunAfterBoth_sourceCancelled3() { + 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 r = new Noop(); + + assertTrue(g.cancel(mayInterruptIfRunning)); + f.complete(v1); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(g); + assertFalse(r.ran); + checkCompletedNormally(f, v1); + } + } + + public void testRunAfterBoth_sourceCancelled4() { + 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 r = new Noop(); + + assertTrue(f.cancel(mayInterruptIfRunning)); + g.complete(v1); + final CompletableFuture h = m.runAfterBoth(f, g, r); + + checkCompletedWithWrappedCancellationException(h); + checkCancelled(f); + assertFalse(r.ran); + checkCompletedNormally(g, v1); + } } /** * applyToEither result completes normally after normal completion * of either source */ - 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); + public void testApplyToEither_normalCompletion1() { + 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 r = new IncFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + + f.complete(v1); + checkCompletedNormally(h, inc(v1)); + g.complete(v2); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + checkCompletedNormally(h, inc(v1)); + } + } - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.applyToEither(f2, inc); - checkCompletedNormally(g, two); + public void testApplyToEither_normalCompletion2() { + 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 r = new IncFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + + g.complete(v2); + checkCompletedNormally(h, inc(v2)); + f.complete(v1); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + checkCompletedNormally(h, inc(v2)); + } + } + public void testApplyToEither_normalCompletion3() { + 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 r = new IncFunction(); + + f.complete(v1); + g.complete(v2); + final CompletableFuture h = m.applyToEither(f, g, r); + + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + + // unspecified behavior + assertTrue(Objects.equals(h.join(), inc(v1)) || + Objects.equals(h.join(), inc(v2))); + } } /** * applyToEither result completes exceptionally after exceptional * completion of either 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); + public void testApplyToEither_exceptionalCompletion1() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction r = new IncFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + final CFException ex = new CFException(); + + f.completeExceptionally(ex); + checkCompletedWithWrappedCFException(h, ex); + g.complete(v1); + + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCFException(f, ex); + checkCompletedWithWrappedCFException(h, ex); + } + } - f = new CompletableFuture(); - f2 = new CompletableFuture(); - f2.completeExceptionally(new CFException()); - g = f.applyToEither(f2, inc); - checkCompletedWithWrappedCFException(g); + public void testApplyToEither_exceptionalCompletion2() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction r = new IncFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + checkCompletedWithWrappedCFException(h, ex); + f.complete(v1); + + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + checkCompletedWithWrappedCFException(g, ex); + checkCompletedWithWrappedCFException(h, ex); + } + } + + public void testApplyToEither_exceptionalCompletion3() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction r = new IncFunction(); + final CFException ex = new CFException(); + + g.completeExceptionally(ex); + f.complete(v1); + final CompletableFuture h = m.applyToEither(f, g, r); + + // unspecified behavior + Integer v; + try { + assertEquals(h.join(), inc(v1)); + assertTrue(r.ran()); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h, ex); + assertFalse(r.ran()); + } + + checkCompletedWithWrappedCFException(g, ex); + checkCompletedNormally(f, v1); + } + } + + public void testApplyToEither_exceptionalCompletion4() { + for (ExecutionMode m : ExecutionMode.values()) + for (Integer v1 : new Integer[] { 1, null }) { + + final CompletableFuture f = new CompletableFuture<>(); + final CompletableFuture g = new CompletableFuture<>(); + final IncFunction r = new IncFunction(); + final CFException ex = new CFException(); + + f.completeExceptionally(ex); + g.complete(v1); + final CompletableFuture h = m.applyToEither(f, g, r); + + // unspecified behavior + Integer v; + try { + assertEquals(h.join(), inc(v1)); + assertTrue(r.ran()); + } catch (CompletionException ok) { + checkCompletedWithWrappedCFException(h, ex); + assertFalse(r.ran()); + } + + checkCompletedWithWrappedCFException(f, ex); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + } } /** * 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); + public void testApplyToEither_actionFailed1() { + 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 r = new FailingFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + + f.complete(v1); + checkCompletedWithWrappedCFException(h); + g.complete(v2); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } + } + + public void testApplyToEither_actionFailed2() { + 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 r = new FailingFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + + g.complete(v2); + checkCompletedWithWrappedCFException(h); + f.complete(v1); + checkCompletedNormally(f, v1); + checkCompletedNormally(g, v2); + } } /** * applyToEither result completes exceptionally if either source cancelled */ - 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 testApplyToEither_sourceCancelled1() { + 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 r = new IncFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + + assertTrue(f.cancel(mayInterruptIfRunning)); + checkCompletedWithWrappedCancellationException(h); + g.complete(v1); + + checkCancelled(f); + assertFalse(r.ran()); + checkCompletedNormally(g, v1); + checkCompletedWithWrappedCancellationException(h); + } + } + + public void testApplyToEither_sourceCancelled2() { + 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 r = new IncFunction(); + final CompletableFuture h = m.applyToEither(f, g, r); + + assertTrue(g.cancel(mayInterruptIfRunning)); + checkCompletedWithWrappedCancellationException(h); + f.complete(v1); + + checkCancelled(g); + assertFalse(r.ran()); + checkCompletedNormally(f, v1); + checkCompletedWithWrappedCancellationException(h); + } + } + + public void testApplyToEither_sourceCancelled3() { + 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 r = new IncFunction(); + + assertTrue(g.cancel(mayInterruptIfRunning)); + f.complete(v1); + final CompletableFuture h = m.applyToEither(f, g, r); + + // unspecified behavior + Integer v; + try { + assertEquals(h.join(), inc(v1)); + assertTrue(r.ran()); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h); + assertFalse(r.ran()); + } + + checkCancelled(g); + checkCompletedNormally(f, v1); + } + } + + public void testApplyToEither_sourceCancelled4() { + 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 r = new IncFunction(); + + assertTrue(f.cancel(mayInterruptIfRunning)); + g.complete(v1); + final CompletableFuture h = m.applyToEither(f, g, r); + + // unspecified behavior + Integer v; + try { + assertEquals(h.join(), inc(v1)); + assertTrue(r.ran()); + } catch (CompletionException ok) { + checkCompletedWithWrappedCancellationException(h); + assertFalse(r.ran()); + } + + checkCancelled(f); + checkCompletedNormally(g, v1); + } } /** @@ -981,23 +2153,23 @@ public class CompletableFutureTest exten * of either source */ public void testAcceptEither() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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); + assertEquals(r.value, (Integer) 2); r = new IncAction(); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); - f2 = new CompletableFuture(); + f2 = new CompletableFuture<>(); g = f.acceptEither(f2, r); checkCompletedNormally(g, null); - assertEquals(r.value, 2); + assertEquals(r.value, (Integer) 2); } /** @@ -1005,8 +2177,8 @@ public class CompletableFutureTest exten * completion of either source */ public void testAcceptEither2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.acceptEither(f2, r); f.completeExceptionally(new CFException()); @@ -1014,8 +2186,8 @@ public class CompletableFutureTest exten checkCompletedWithWrappedCFException(g); r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); f2.completeExceptionally(new CFException()); g = f.acceptEither(f2, r); checkCompletedWithWrappedCFException(g); @@ -1025,8 +2197,8 @@ public class CompletableFutureTest exten * acceptEither result completes exceptionally if action does */ public void testAcceptEither3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); FailingConsumer r = new FailingConsumer(); CompletableFuture g = f.acceptEither(f2, r); f2.complete(two); @@ -1037,26 +2209,25 @@ public class CompletableFutureTest exten * acceptEither result completes exceptionally if either source cancelled */ public void testAcceptEither4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); assertTrue(f2.cancel(true)); checkCompletedWithWrappedCancellationException(g); } - /** * runAfterEither result completes normally after normal completion * of either source */ public void testRunAfterEither() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.runAfterEither(f2, r); f.complete(one); @@ -1066,9 +2237,9 @@ public class CompletableFutureTest exten assertTrue(r.ran); r = new Noop(); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); - f2 = new CompletableFuture(); + f2 = new CompletableFuture<>(); g = f.runAfterEither(f2, r); checkCompletedNormally(g, null); assertTrue(r.ran); @@ -1079,8 +2250,8 @@ public class CompletableFutureTest exten * completion of either source */ public void testRunAfterEither2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.runAfterEither(f2, r); f.completeExceptionally(new CFException()); @@ -1088,8 +2259,8 @@ public class CompletableFutureTest exten checkCompletedWithWrappedCFException(g); r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); f2.completeExceptionally(new CFException()); g = f.runAfterEither(f2, r); checkCompletedWithWrappedCFException(g); @@ -1099,8 +2270,8 @@ public class CompletableFutureTest exten * runAfterEither result completes exceptionally if action does */ public void testRunAfterEither3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); FailingNoop r = new FailingNoop(); CompletableFuture g = f.runAfterEither(f2, r); f2.complete(two); @@ -1111,14 +2282,14 @@ public class CompletableFutureTest exten * runAfterEither result completes exceptionally if either source cancelled */ public void testRunAfterEither4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); assertTrue(f2.cancel(true)); checkCompletedWithWrappedCancellationException(g); } @@ -1130,13 +2301,13 @@ public class CompletableFutureTest exten CompletableFuture f, g; CompletableFutureInc r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenCompose(r = new CompletableFutureInc()); f.complete(one); checkCompletedNormally(g, two); assertTrue(r.ran); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); g = f.thenCompose(r = new CompletableFutureInc()); checkCompletedNormally(g, two); @@ -1151,12 +2322,12 @@ public class CompletableFutureTest exten CompletableFuture f, g; CompletableFutureInc r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenCompose(r = new CompletableFutureInc()); f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.completeExceptionally(new CFException()); g = f.thenCompose(r = new CompletableFutureInc()); checkCompletedWithWrappedCFException(g); @@ -1169,12 +2340,12 @@ public class CompletableFutureTest exten CompletableFuture f, g; FailingCompletableFutureFunction r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenCompose(r = new FailingCompletableFutureFunction()); f.complete(one); checkCompletedWithWrappedCFException(g); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); g = f.thenCompose(r = new FailingCompletableFutureFunction()); checkCompletedWithWrappedCFException(g); @@ -1187,32 +2358,31 @@ public class CompletableFutureTest exten CompletableFuture f, g; CompletableFutureInc r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenCompose(r = new CompletableFutureInc()); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); + f = new CompletableFuture<>(); assertTrue(f.cancel(true)); g = f.thenCompose(r = new CompletableFutureInc()); checkCompletedWithWrappedCancellationException(g); } - // asyncs /** * thenRunAsync result completes normally after normal completion of source */ public void testThenRunAsync() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.thenRunAsync(r); f.complete(null); checkCompletedNormally(g, null); // reordered version - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(null); r = new Noop(); g = f.thenRunAsync(r); @@ -1224,15 +2394,14 @@ public class CompletableFutureTest exten * completion of source */ public void testThenRunAsync2() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.thenRunAsync(r); f.completeExceptionally(new CFException()); try { g.join(); shouldThrow(); - } catch (Exception ok) { - } + } catch (CompletionException success) {} checkCompletedWithWrappedCFException(g); } @@ -1240,7 +2409,7 @@ public class CompletableFutureTest exten * thenRunAsync result completes exceptionally if action does */ public void testThenRunAsync3() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingNoop r = new FailingNoop(); CompletableFuture g = f.thenRunAsync(r); f.complete(null); @@ -1251,7 +2420,7 @@ public class CompletableFutureTest exten * thenRunAsync result completes exceptionally if source cancelled */ public void testThenRunAsync4() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.thenRunAsync(r); assertTrue(f.cancel(true)); @@ -1262,7 +2431,7 @@ public class CompletableFutureTest exten * thenApplyAsync result completes normally after normal completion of source */ public void testThenApplyAsync() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApplyAsync(inc); f.complete(one); checkCompletedNormally(g, two); @@ -1273,7 +2442,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenApplyAsync2() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApplyAsync(inc); f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); @@ -1283,7 +2452,7 @@ public class CompletableFutureTest exten * thenApplyAsync result completes exceptionally if action does */ public void testThenApplyAsync3() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingFunction r = new FailingFunction(); CompletableFuture g = f.thenApplyAsync(r); f.complete(null); @@ -1294,7 +2463,7 @@ public class CompletableFutureTest exten * thenApplyAsync result completes exceptionally if source cancelled */ public void testThenApplyAsync4() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApplyAsync(inc); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); @@ -1305,12 +2474,12 @@ public class CompletableFutureTest exten * completion of source */ public void testThenAcceptAsync() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAcceptAsync(r); f.complete(one); checkCompletedNormally(g, null); - assertEquals(r.value, 2); + assertEquals(r.value, (Integer) 2); } /** @@ -1318,7 +2487,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenAcceptAsync2() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAcceptAsync(r); f.completeExceptionally(new CFException()); @@ -1329,7 +2498,7 @@ public class CompletableFutureTest exten * thenAcceptAsync result completes exceptionally if action does */ public void testThenAcceptAsync3() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingConsumer r = new FailingConsumer(); CompletableFuture g = f.thenAcceptAsync(r); f.complete(null); @@ -1340,7 +2509,7 @@ public class CompletableFutureTest exten * thenAcceptAsync result completes exceptionally if source cancelled */ public void testThenAcceptAsync4() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAcceptAsync(r); assertTrue(f.cancel(true)); @@ -1348,352 +2517,25 @@ public class CompletableFutureTest exten } /** - * thenCombineAsync result completes normally after normal - * completion of sources - */ - public void testThenCombineAsync() { - CompletableFuture f, g, h; - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract); - f.complete(3); - checkIncomplete(h); - g.complete(1); - checkCompletedNormally(h, 2); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract); - g.complete(1); - checkIncomplete(h); - f.complete(3); - checkCompletedNormally(h, 2); - - f = new CompletableFuture(); - g = new CompletableFuture(); - g.complete(1); - f.complete(3); - h = f.thenCombineAsync(g, subtract); - checkCompletedNormally(h, 2); - } - - /** - * thenCombineAsync result completes exceptionally after exceptional - * completion of either source - */ - public void testThenCombineAsync2() { - CompletableFuture f, g, h; - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract); - f.completeExceptionally(new CFException()); - checkIncomplete(h); - g.complete(1); - checkCompletedWithWrappedCFException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract); - g.completeExceptionally(new CFException()); - checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCFException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - g.completeExceptionally(new CFException()); - f.complete(3); - h = f.thenCombineAsync(g, subtract); - checkCompletedWithWrappedCFException(h); - } - - /** - * 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); - assertFalse(r.ran); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - assertTrue(r.ran); - } - - /** - * thenCombineAsync result completes exceptionally if either source cancelled - */ - public void testThenCombineAsync4() { - CompletableFuture f, g, h; - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract); - assertTrue(f.cancel(true)); - checkIncomplete(h); - g.complete(1); - checkCompletedWithWrappedCancellationException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract); - assertTrue(g.cancel(true)); - checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCancellationException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - g.complete(3); - assertTrue(f.cancel(true)); - h = f.thenCombineAsync(g, subtract); - checkCompletedWithWrappedCancellationException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - f.complete(3); - assertTrue(g.cancel(true)); - h = f.thenCombineAsync(g, subtract); - checkCompletedWithWrappedCancellationException(h); - } - - /** - * 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); - } - - /** - * thenAcceptBothAsync 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); - - r = new AddAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.thenAcceptBothAsync(f2, r); - f.complete(one); - f2.completeExceptionally(new CFException()); - checkCompletedWithWrappedCFException(g); - } - - /** - * 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 - */ - 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); - - 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); - } - - /** - * runAfterBothAsync result completes exceptionally after exceptional - * completion of source - */ - 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); - } - - /** - * 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); - } - - /** - * runAfterBothAsync result completes exceptionally if either source cancelled - */ - 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); - - r = new Noop(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); - g = f.runAfterBothAsync(f2, r); - f.complete(one); - assertTrue(f2.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - } - - /** - * applyToEitherAsync result completes normally after normal - * completion of sources - */ - public void testApplyToEitherAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc); - f.complete(one); - checkCompletedNormally(g, two); - - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.applyToEitherAsync(f2, inc); - checkCompletedNormally(g, two); - } - - /** - * applyToEitherAsync result completes exceptionally after exceptional - * completion of source - */ - 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); - } - - /** - * 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); - } - - /** - * applyToEitherAsync result completes exceptionally if either source cancelled - */ - public void testApplyToEitherAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); - CompletableFuture g = f.applyToEitherAsync(f2, inc); - assertTrue(f.cancel(true)); - checkCompletedWithWrappedCancellationException(g); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.applyToEitherAsync(f2, inc); - checkCompletedWithWrappedCancellationException(g); - } - - /** * acceptEitherAsync result completes normally after normal * completion of sources */ public void testAcceptEitherAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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); + assertEquals(r.value, (Integer) 2); r = new IncAction(); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); - f2 = new CompletableFuture(); + f2 = new CompletableFuture<>(); g = f.acceptEitherAsync(f2, r); checkCompletedNormally(g, null); - assertEquals(r.value, 2); + assertEquals(r.value, (Integer) 2); } /** @@ -1701,16 +2543,16 @@ public class CompletableFutureTest exten * completion of source */ public void testAcceptEitherAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); f2.completeExceptionally(new CFException()); g = f.acceptEitherAsync(f2, r); f.complete(one); @@ -1721,8 +2563,8 @@ public class CompletableFutureTest exten * acceptEitherAsync result completes exceptionally if action does */ public void testAcceptEitherAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); FailingConsumer r = new FailingConsumer(); CompletableFuture g = f.acceptEitherAsync(f2, r); f.complete(one); @@ -1734,16 +2576,16 @@ public class CompletableFutureTest exten * source cancelled */ public void testAcceptEitherAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.acceptEitherAsync(f2, r); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); assertTrue(f2.cancel(true)); g = f.acceptEitherAsync(f2, r); checkCompletedWithWrappedCancellationException(g); @@ -1754,8 +2596,8 @@ public class CompletableFutureTest exten * completion of sources */ public void testRunAfterEitherAsync() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.runAfterEitherAsync(f2, r); f.complete(one); @@ -1763,9 +2605,9 @@ public class CompletableFutureTest exten assertTrue(r.ran); r = new Noop(); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); - f2 = new CompletableFuture(); + f2 = new CompletableFuture<>(); g = f.runAfterEitherAsync(f2, r); checkCompletedNormally(g, null); assertTrue(r.ran); @@ -1776,16 +2618,16 @@ public class CompletableFutureTest exten * completion of source */ public void testRunAfterEitherAsync2() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); f2.completeExceptionally(new CFException()); g = f.runAfterEitherAsync(f2, r); f.complete(one); @@ -1796,8 +2638,8 @@ public class CompletableFutureTest exten * runAfterEitherAsync result completes exceptionally if action does */ public void testRunAfterEitherAsync3() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); FailingNoop r = new FailingNoop(); CompletableFuture g = f.runAfterEitherAsync(f2, r); f.complete(one); @@ -1809,16 +2651,16 @@ public class CompletableFutureTest exten * source cancelled */ public void testRunAfterEitherAsync4() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); assertTrue(f2.cancel(true)); g = f.runAfterEitherAsync(f2, r); checkCompletedWithWrappedCancellationException(g); @@ -1832,12 +2674,12 @@ public class CompletableFutureTest exten CompletableFuture f, g; CompletableFutureInc r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenComposeAsync(r = new CompletableFutureInc()); f.complete(one); checkCompletedNormally(g, two); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); g = f.thenComposeAsync(r = new CompletableFutureInc()); checkCompletedNormally(g, two); @@ -1851,13 +2693,13 @@ public class CompletableFutureTest exten CompletableFuture f, g; CompletableFutureInc r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenComposeAsync(r = new CompletableFutureInc()); f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); assertFalse(r.ran); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.completeExceptionally(new CFException()); g = f.thenComposeAsync(r = new CompletableFutureInc()); checkCompletedWithWrappedCFException(g); @@ -1871,12 +2713,12 @@ public class CompletableFutureTest exten CompletableFuture f, g; FailingCompletableFutureFunction r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenComposeAsync(r = new FailingCompletableFutureFunction()); f.complete(one); checkCompletedWithWrappedCFException(g); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); g = f.thenComposeAsync(r = new FailingCompletableFutureFunction()); checkCompletedWithWrappedCFException(g); @@ -1889,32 +2731,31 @@ public class CompletableFutureTest exten CompletableFuture f, g; CompletableFutureInc r; - f = new CompletableFuture(); + f = new CompletableFuture<>(); g = f.thenComposeAsync(r = new CompletableFutureInc()); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); - f = new CompletableFuture(); + f = new CompletableFuture<>(); assertTrue(f.cancel(true)); g = f.thenComposeAsync(r = new CompletableFutureInc()); checkCompletedWithWrappedCancellationException(g); } - // async with explicit executors /** * thenRunAsync result completes normally after normal completion of source */ public void testThenRunAsyncE() { - CompletableFuture f = new CompletableFuture(); + 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 = new CompletableFuture<>(); f.complete(null); r = new Noop(); g = f.thenRunAsync(r, new ThreadExecutor()); @@ -1926,15 +2767,14 @@ public class CompletableFutureTest exten * completion of source */ public void testThenRunAsync2E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); f.completeExceptionally(new CFException()); try { g.join(); shouldThrow(); - } catch (Exception ok) { - } + } catch (CompletionException success) {} checkCompletedWithWrappedCFException(g); } @@ -1942,7 +2782,7 @@ public class CompletableFutureTest exten * thenRunAsync result completes exceptionally if action does */ public void testThenRunAsync3E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingNoop r = new FailingNoop(); CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); f.complete(null); @@ -1953,7 +2793,7 @@ public class CompletableFutureTest exten * thenRunAsync result completes exceptionally if source cancelled */ public void testThenRunAsync4E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.thenRunAsync(r, new ThreadExecutor()); assertTrue(f.cancel(true)); @@ -1964,7 +2804,7 @@ public class CompletableFutureTest exten * thenApplyAsync result completes normally after normal completion of source */ public void testThenApplyAsyncE() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApplyAsync(inc, new ThreadExecutor()); f.complete(one); checkCompletedNormally(g, two); @@ -1975,7 +2815,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenApplyAsync2E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApplyAsync(inc, new ThreadExecutor()); f.completeExceptionally(new CFException()); checkCompletedWithWrappedCFException(g); @@ -1985,7 +2825,7 @@ public class CompletableFutureTest exten * thenApplyAsync result completes exceptionally if action does */ public void testThenApplyAsync3E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingFunction r = new FailingFunction(); CompletableFuture g = f.thenApplyAsync(r, new ThreadExecutor()); f.complete(null); @@ -1996,7 +2836,7 @@ public class CompletableFutureTest exten * thenApplyAsync result completes exceptionally if source cancelled */ public void testThenApplyAsync4E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFuture g = f.thenApplyAsync(inc, new ThreadExecutor()); assertTrue(f.cancel(true)); checkCompletedWithWrappedCancellationException(g); @@ -2007,12 +2847,12 @@ public class CompletableFutureTest exten * completion of source */ public void testThenAcceptAsyncE() { - CompletableFuture f = new CompletableFuture(); + 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); + assertEquals(r.value, (Integer) 2); } /** @@ -2020,7 +2860,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenAcceptAsync2E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); f.completeExceptionally(new CFException()); @@ -2031,7 +2871,7 @@ public class CompletableFutureTest exten * thenAcceptAsync result completes exceptionally if action does */ public void testThenAcceptAsync3E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingConsumer r = new FailingConsumer(); CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); f.complete(null); @@ -2042,7 +2882,7 @@ public class CompletableFutureTest exten * thenAcceptAsync result completes exceptionally if source cancelled */ public void testThenAcceptAsync4E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); IncAction r = new IncAction(); CompletableFuture g = f.thenAcceptAsync(r, new ThreadExecutor()); assertTrue(f.cancel(true)); @@ -2050,366 +2890,25 @@ public class CompletableFutureTest exten } /** - * thenCombineAsync result completes normally after normal - * completion of sources - */ - public void testThenCombineAsyncE() { - CompletableFuture f, g, h; - ThreadExecutor e = new ThreadExecutor(); - int count = 0; - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract, e); - f.complete(3); - checkIncomplete(h); - g.complete(1); - checkCompletedNormally(h, 2); - assertEquals(++count, e.count.get()); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract, e); - g.complete(1); - checkIncomplete(h); - f.complete(3); - checkCompletedNormally(h, 2); - assertEquals(++count, e.count.get()); - - f = new CompletableFuture(); - g = new CompletableFuture(); - g.complete(1); - f.complete(3); - h = f.thenCombineAsync(g, subtract, e); - checkCompletedNormally(h, 2); - assertEquals(++count, e.count.get()); - } - - /** - * thenCombineAsync result completes exceptionally after exceptional - * completion of either source - */ - public void testThenCombineAsync2E() { - CompletableFuture f, g, h; - ThreadExecutor e = new ThreadExecutor(); - int count = 0; - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract, e); - f.completeExceptionally(new CFException()); - checkIncomplete(h); - g.complete(1); - checkCompletedWithWrappedCFException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract, e); - g.completeExceptionally(new CFException()); - checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCFException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - g.completeExceptionally(new CFException()); - h = f.thenCombineAsync(g, subtract, e); - checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCFException(h); - - assertEquals(0, e.count.get()); - } - - /** - * 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); - assertFalse(r.ran); - f2.complete(two); - checkCompletedWithWrappedCFException(g); - assertTrue(r.ran); - } - - /** - * thenCombineAsync result completes exceptionally if either source cancelled - */ - public void testThenCombineAsync4E() { - CompletableFuture f, g, h; - ThreadExecutor e = new ThreadExecutor(); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract, e); - assertTrue(f.cancel(true)); - checkIncomplete(h); - g.complete(1); - checkCompletedWithWrappedCancellationException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - h = f.thenCombineAsync(g, subtract, e); - assertTrue(g.cancel(true)); - checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCancellationException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - assertTrue(g.cancel(true)); - h = f.thenCombineAsync(g, subtract, e); - checkIncomplete(h); - f.complete(3); - checkCompletedWithWrappedCancellationException(h); - - f = new CompletableFuture(); - g = new CompletableFuture(); - assertTrue(f.cancel(true)); - assertTrue(g.cancel(true)); - h = f.thenCombineAsync(g, subtract, e); - checkCompletedWithWrappedCancellationException(h); - - assertEquals(0, e.count.get()); - } - - /** - * thenAcceptBothAsync result completes normally after normal - * completion of sources - */ - 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); - } - - /** - * 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); - - 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); - } - - /** - * 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); - } - - /** - * thenAcceptBothAsync result completes exceptionally if either source cancelled - */ - 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); - } - - /** - * runAfterBothAsync result completes normally after normal - * completion of sources - */ - 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); - } - - /** - * runAfterBothAsync result completes exceptionally after exceptional - * completion of 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); - } - - /** - * 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); - } - - /** - * 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); - - 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); - } - - /** - * applyToEitherAsync result completes normally after normal - * completion of sources - */ - 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); - - f = new CompletableFuture(); - f.complete(one); - f2 = new CompletableFuture(); - g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - checkCompletedNormally(g, two); - } - - /** - * applyToEitherAsync result completes exceptionally after exceptional - * completion of source - */ - 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); - } - - /** - * applyToEitherAsync result completes exceptionally if action does - */ - 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); - } - - /** - * applyToEitherAsync result completes exceptionally if either source cancelled - */ - 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); - - f = new CompletableFuture(); - f2 = new CompletableFuture(); - assertTrue(f2.cancel(true)); - g = f.applyToEitherAsync(f2, inc, new ThreadExecutor()); - checkCompletedWithWrappedCancellationException(g); - } - - /** * acceptEitherAsync result completes normally after normal * completion of sources */ public void testAcceptEitherAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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); + assertEquals(r.value, (Integer) 2); r = new IncAction(); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); - f2 = new CompletableFuture(); + f2 = new CompletableFuture<>(); g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); checkCompletedNormally(g, null); - assertEquals(r.value, 2); + assertEquals(r.value, (Integer) 2); } /** @@ -2417,16 +2916,16 @@ public class CompletableFutureTest exten * completion of source */ public void testAcceptEitherAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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); r = new IncAction(); - f = new CompletableFuture(); - f2 = new CompletableFuture(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); f2.completeExceptionally(new CFException()); g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); f.complete(one); @@ -2437,8 +2936,8 @@ public class CompletableFutureTest exten * acceptEitherAsync result completes exceptionally if action does */ public void testAcceptEitherAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); FailingConsumer r = new FailingConsumer(); CompletableFuture g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); f.complete(one); @@ -2450,16 +2949,16 @@ public class CompletableFutureTest exten * source cancelled */ public void testAcceptEitherAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); assertTrue(f2.cancel(true)); g = f.acceptEitherAsync(f2, r, new ThreadExecutor()); checkCompletedWithWrappedCancellationException(g); @@ -2470,8 +2969,8 @@ public class CompletableFutureTest exten * completion of sources */ public void testRunAfterEitherAsyncE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); Noop r = new Noop(); CompletableFuture g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); f.complete(one); @@ -2479,9 +2978,9 @@ public class CompletableFutureTest exten assertTrue(r.ran); r = new Noop(); - f = new CompletableFuture(); + f = new CompletableFuture<>(); f.complete(one); - f2 = new CompletableFuture(); + f2 = new CompletableFuture<>(); g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); checkCompletedNormally(g, null); assertTrue(r.ran); @@ -2492,16 +2991,16 @@ public class CompletableFutureTest exten * completion of source */ public void testRunAfterEitherAsync2E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); f2.completeExceptionally(new CFException()); g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); f.complete(one); @@ -2512,8 +3011,8 @@ public class CompletableFutureTest exten * runAfterEitherAsync result completes exceptionally if action does */ public void testRunAfterEitherAsync3E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture f2 = new CompletableFuture<>(); FailingNoop r = new FailingNoop(); CompletableFuture g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); f.complete(one); @@ -2525,16 +3024,16 @@ public class CompletableFutureTest exten * source cancelled */ public void testRunAfterEitherAsync4E() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture f2 = new CompletableFuture(); + 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(); + f = new CompletableFuture<>(); + f2 = new CompletableFuture<>(); assertTrue(f2.cancel(true)); g = f.runAfterEitherAsync(f2, r, new ThreadExecutor()); checkCompletedWithWrappedCancellationException(g); @@ -2545,7 +3044,7 @@ public class CompletableFutureTest exten * completion of source */ public void testThenComposeAsyncE() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFutureInc r = new CompletableFutureInc(); CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); f.complete(one); @@ -2557,7 +3056,7 @@ public class CompletableFutureTest exten * exceptional completion of source */ public void testThenComposeAsync2E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFutureInc r = new CompletableFutureInc(); CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); f.completeExceptionally(new CFException()); @@ -2568,7 +3067,7 @@ public class CompletableFutureTest exten * thenComposeAsync result completes exceptionally if action does */ public void testThenComposeAsync3E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); FailingCompletableFutureFunction r = new FailingCompletableFutureFunction(); CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); f.complete(one); @@ -2579,7 +3078,7 @@ public class CompletableFutureTest exten * thenComposeAsync result completes exceptionally if source cancelled */ public void testThenComposeAsync4E() { - CompletableFuture f = new CompletableFuture(); + CompletableFuture f = new CompletableFuture<>(); CompletableFutureInc r = new CompletableFutureInc(); CompletableFuture g = f.thenComposeAsync(r, new ThreadExecutor()); assertTrue(f.cancel(true)); @@ -2593,24 +3092,27 @@ 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); } } @@ -2618,23 +3120,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); } /** - * anyOf 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)); } } } @@ -2643,108 +3165,339 @@ public class CompletableFutureTest exten * Completion methods throw NullPointerException with null arguments */ public void testNPE() { - CompletableFuture f = new CompletableFuture(); - CompletableFuture g = new CompletableFuture(); + 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(supplyOne, 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(), 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); }, + () -> CompletableFuture.supplyAsync(null), + () -> CompletableFuture.supplyAsync(null, exec), + () -> CompletableFuture.supplyAsync(supplyOne, 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(), 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 testWhenComplete1() { + final AtomicInteger a = new AtomicInteger(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement()); + f.complete(three); + checkCompletedNormally(f, three); + checkCompletedNormally(g, three); + assertEquals(a.get(), 1); + } + + /** + * whenComplete action executes on exceptional completion, propagating + * source result. + */ + public void testWhenComplete2() { + final AtomicInteger a = new AtomicInteger(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement()); + f.completeExceptionally(new CFException()); + assertTrue(f.isCompletedExceptionally()); + assertTrue(g.isCompletedExceptionally()); + assertEquals(a.get(), 1); + } + + /** + * If a whenComplete action throws an exception when triggered by + * a normal completion, it completes exceptionally + */ + public void testWhenComplete3() { + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenComplete((Integer x, Throwable t) -> + { throw new CFException(); } ); + f.complete(three); + checkCompletedNormally(f, three); + assertTrue(g.isCompletedExceptionally()); + checkCompletedWithWrappedCFException(g); + } + + /** + * whenCompleteAsync action executes on normal completion, propagating + * source result. + */ + public void testWhenCompleteAsync1() { + final AtomicInteger a = new AtomicInteger(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement()); + f.complete(three); + checkCompletedNormally(f, three); + checkCompletedNormally(g, three); + assertEquals(a.get(), 1); + } + + /** + * whenCompleteAsync action executes on exceptional completion, propagating + * source result. + */ + public void testWhenCompleteAsync2() { + final AtomicInteger a = new AtomicInteger(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement()); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedWithWrappedCFException(g); + } + + /** + * If a whenCompleteAsync action throws an exception when + * triggered by a normal completion, it completes exceptionally + */ + public void testWhenCompleteAsync3() { + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenCompleteAsync((Integer x, Throwable t) -> + { throw new CFException(); } ); + f.complete(three); + checkCompletedNormally(f, three); + checkCompletedWithWrappedCFException(g); + } + + /** + * whenCompleteAsync action executes on normal completion, propagating + * source result. + */ + public void testWhenCompleteAsync1e() { + final AtomicInteger a = new AtomicInteger(); + ThreadExecutor exec = new ThreadExecutor(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(), + exec); + f.complete(three); + checkCompletedNormally(f, three); + checkCompletedNormally(g, three); + assertEquals(a.get(), 1); + } + + /** + * whenCompleteAsync action executes on exceptional completion, propagating + * source result. + */ + public void testWhenCompleteAsync2e() { + final AtomicInteger a = new AtomicInteger(); + ThreadExecutor exec = new ThreadExecutor(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(), + exec); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedWithWrappedCFException(g); + } + + /** + * If a whenCompleteAsync action throws an exception when triggered + * by a normal completion, it completes exceptionally + */ + public void testWhenCompleteAsync3e() { + ThreadExecutor exec = new ThreadExecutor(); + CompletableFuture f = new CompletableFuture<>(); + CompletableFuture g = + f.whenCompleteAsync((Integer x, Throwable t) -> + { throw new CFException(); }, + exec); + f.complete(three); + checkCompletedNormally(f, three); + checkCompletedWithWrappedCFException(g); + } + + /** + * handleAsync action completes normally with function value on + * either normal or exceptional completion of source + */ + public void testHandleAsync() { + CompletableFuture f, g; + IntegerHandler r; + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler()); + assertFalse(r.ran); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedNormally(g, three); + assertTrue(r.ran); + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler()); + assertFalse(r.ran); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedNormally(g, three); + assertTrue(r.ran); + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler()); + assertFalse(r.ran); + f.complete(one); + checkCompletedNormally(f, one); + checkCompletedNormally(g, two); + assertTrue(r.ran); + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler()); + assertFalse(r.ran); + f.complete(one); + checkCompletedNormally(f, one); + checkCompletedNormally(g, two); + assertTrue(r.ran); + } + + /** + * handleAsync action with Executor completes normally with + * function value on either normal or exceptional completion of + * source + */ + public void testHandleAsync2() { + CompletableFuture f, g; + ThreadExecutor exec = new ThreadExecutor(); + IntegerHandler r; + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler(), exec); + assertFalse(r.ran); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedNormally(g, three); + assertTrue(r.ran); + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler(), exec); + assertFalse(r.ran); + f.completeExceptionally(new CFException()); + checkCompletedWithWrappedCFException(f); + checkCompletedNormally(g, three); + assertTrue(r.ran); + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler(), exec); + assertFalse(r.ran); + f.complete(one); + checkCompletedNormally(f, one); + checkCompletedNormally(g, two); + assertTrue(r.ran); + + f = new CompletableFuture<>(); + g = f.handleAsync(r = new IntegerHandler(), exec); + assertFalse(r.ran); + f.complete(one); + checkCompletedNormally(f, one); + checkCompletedNormally(g, two); + assertTrue(r.ran); + } + }