@Test
public void testReconnect() throws Exception {
CompletableFuture<Boolean> firstStartFuture = new CompletableFuture<>();
CompletableFuture<Boolean> secondStartFuture = new CompletableFuture<>();
doAnswer(
invocation -> {
if (!firstStartFuture.isDone()) {
firstStartFuture.complete(true);
throw new IOException("test exception");
}
secondStartFuture.complete(true);
botShutdownLatch.await();
return null;
})
.when(pircBotX)
.startBot();
instance.connect();
firstStartFuture.get(TIMEOUT, TIMEOUT_UNIT);
secondStartFuture.get(TIMEOUT, TIMEOUT_UNIT);
verify(pircBotX, times(2)).startBot();
}
static void checkCompletedNormally(CompletableFuture<?> cf, Object[] values) {
try {
equalAnyOf(cf.join(), values);
} catch (Throwable x) {
unexpected(x);
}
try {
equalAnyOf(cf.getNow(null), values);
} catch (Throwable x) {
unexpected(x);
}
try {
equalAnyOf(cf.get(), values);
} catch (Throwable x) {
unexpected(x);
}
try {
equalAnyOf(cf.get(0L, SECONDS), values);
} catch (Throwable x) {
unexpected(x);
}
check(cf.isDone(), "Expected isDone to be true, got:" + cf);
check(!cf.isCancelled(), "Expected isCancelled to be false");
check(!cf.cancel(true), "Expected cancel to return false");
check(cf.toString().contains("[Completed normally]"));
check(cf.complete(null) == false, "Expected complete() to fail");
check(
cf.completeExceptionally(new Throwable()) == false,
"Expected completeExceptionally() to fail");
}
/**
* Connects to an RS world.
*
* @param world the world, as a string. For RS3, use a numeric string. For oldschool, use
* "oldschool[world]".
* @return A future for the connection task.
*/
public CompletableFuture<Void> connect(String world) {
if (connectionTask != null && !connectionTask.isDone()) {
connectionTask.cancel(true);
}
disconnect();
String host;
int port;
if (world.startsWith("oldschool")) {
host = world + HOST_SUFFIX;
port = OLDSCHOOL_PORT;
} else {
host = "world" + world + HOST_SUFFIX;
port = RS3_PORT;
}
connectionTask = new CompletableFuture<>();
CompletableFuture.runAsync(
() -> {
try {
synchronized (this) {
socket = new Socket(host, port);
}
connectionTask.complete(null);
} catch (IOException e) {
connectionTask.completeExceptionally(e);
}
});
return connectionTask;
}
@Test
public void shouldConvertFailureToFailedCompletableFuture() {
final CompletableFuture<Object> future = failure().toCompletableFuture();
assertThat(future.isDone());
assertThat(future.isCompletedExceptionally());
assertThatThrownBy(future::get)
.isExactlyInstanceOf(ExecutionException.class)
.hasCauseExactlyInstanceOf(RuntimeException.class);
}
@SuppressWarnings("unchecked")
static <T> void checkCompletedExceptionally(CompletableFuture<T> cf, boolean cancelled)
throws Exception {
try {
cf.join();
fail("Excepted exception to be thrown");
} catch (CompletionException x) {
if (cancelled) fail();
else pass();
} catch (CancellationException x) {
if (cancelled) pass();
else fail();
}
try {
cf.getNow(null);
fail("Excepted exception to be thrown");
} catch (CompletionException x) {
if (cancelled) fail();
else pass();
} catch (CancellationException x) {
if (cancelled) pass();
else fail();
}
try {
cf.get();
fail("Excepted exception to be thrown");
} catch (CancellationException x) {
if (cancelled) pass();
else fail();
} catch (ExecutionException x) {
if (cancelled) check(x.getCause() instanceof CancellationException);
else pass();
}
try {
cf.get(0L, SECONDS);
fail("Excepted exception to be thrown");
} catch (CancellationException x) {
if (cancelled) pass();
else fail();
} catch (ExecutionException x) {
if (cancelled) check(x.getCause() instanceof CancellationException);
else pass();
}
check(cf.isDone(), "Expected isDone to be true, got:" + cf);
check(
cf.isCancelled() == cancelled,
"Expected isCancelled: " + cancelled + ", got:" + cf.isCancelled());
check(
cf.cancel(true) == cancelled, "Expected cancel: " + cancelled + ", got:" + cf.cancel(true));
check(cf.toString().contains("[Completed exceptionally]")); // ## TODO: 'E'xceptionally
check(cf.complete((T) new Object()) == false, "Expected complete() to fail");
check(
cf.completeExceptionally(new Throwable()) == false,
"Expected completeExceptionally() to fail, already completed");
}
private CompletableFuture<HRegionLocation> withTimeout(
CompletableFuture<HRegionLocation> future, long timeoutNs, Supplier<String> timeoutMsg) {
if (future.isDone() || timeoutNs <= 0) {
return future;
}
Timeout timeoutTask =
retryTimer.newTimeout(
t -> {
if (future.isDone()) {
return;
}
future.completeExceptionally(new TimeoutIOException(timeoutMsg.get()));
},
timeoutNs,
TimeUnit.NANOSECONDS);
return future.whenComplete(
(loc, error) -> {
if (error != null && error.getClass() != TimeoutIOException.class) {
// cancel timeout task if we are not completed by it.
timeoutTask.cancel();
}
});
}
/** Returns the server-side annotations that should be added to a Zipkin span. */
protected List<KeyValueAnnotation> annotations(ServiceRequestContext ctx, RequestLog req, O res) {
final List<KeyValueAnnotation> annotations = new ArrayList<>(5);
final StringBuilder uriBuilder = new StringBuilder();
uriBuilder.append(req.scheme().uriText());
uriBuilder.append("://");
uriBuilder.append(req.host());
uriBuilder.append(ctx.path());
if (req.method() != null) {
uriBuilder.append('#');
uriBuilder.append(req.method());
}
annotations.add(KeyValueAnnotation.create("server.uri", uriBuilder.toString()));
if (ctx.remoteAddress() != null) {
annotations.add(KeyValueAnnotation.create("server.remote", ctx.remoteAddress().toString()));
}
if (ctx.localAddress() != null) {
annotations.add(KeyValueAnnotation.create("server.local", ctx.localAddress().toString()));
}
final CompletableFuture<?> f = res.closeFuture();
if (f.isDone()) {
// Need to use a callback because CompletableFuture does not have a getter for the cause of
// failure.
// The callback will be invoked immediately because the future is done already.
f.handle(
voidFunction(
(result, cause) -> {
final String resultText = cause == null ? "success" : "failure";
annotations.add(KeyValueAnnotation.create("server.result", resultText));
if (cause != null) {
annotations.add(KeyValueAnnotation.create("server.cause", cause.toString()));
}
}))
.exceptionally(CompletionActions::log);
}
return annotations;
}
@Test
public void testAllPrimitivesAndStack() throws IllegalAccessException, InstantiationException {
PrimitiveUser4 a = new PrimitiveUser4();
CompletableFuture<String> blocker = new CompletableFuture<>();
Random r = new Random();
int i1 = r.nextInt();
short s1 = (short) r.nextInt();
byte b1 = (byte) r.nextInt();
double d1 = r.nextDouble();
char c1 = (char) r.nextInt();
boolean z1 = r.nextBoolean();
long g1 = r.nextLong();
Object o1 = new Object();
float f1 = r.nextFloat();
final CompletableFuture<Object> res = a.melange(i1, s1, b1, d1, c1, z1, g1, o1, f1, blocker, 0);
assertFalse(res.isDone());
blocker.complete("x");
assertEquals(":", res.join());
a.assertFields(i1, s1, b1, d1, c1, z1, g1, o1, f1);
}
/** Determines if all items have been returned to the client. */
public boolean allItemsAvailable() {
return readCompleted.isDone();
}
private static void test(ExecutorService executor) throws Throwable {
Thread.currentThread().setName("mainThread");
// ----------------------------------------------------------------
// supplyAsync tests
// ----------------------------------------------------------------
try {
CompletableFuture<String> cf = supplyAsync(() -> "a test string");
checkCompletedNormally(cf, cf.join());
cf = supplyAsync(() -> "a test string", commonPool());
checkCompletedNormally(cf, cf.join());
cf = supplyAsync(() -> "a test string", executor);
checkCompletedNormally(cf, cf.join());
cf =
supplyAsync(
() -> {
throw new RuntimeException();
});
checkCompletedExceptionally(cf);
cf =
supplyAsync(
() -> {
throw new RuntimeException();
},
commonPool());
checkCompletedExceptionally(cf);
cf =
supplyAsync(
() -> {
throw new RuntimeException();
},
executor);
checkCompletedExceptionally(cf);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// runAsync tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf = runAsync(() -> {});
checkCompletedNormally(cf, cf.join());
cf = runAsync(() -> {}, commonPool());
checkCompletedNormally(cf, cf.join());
cf = runAsync(() -> {}, executor);
checkCompletedNormally(cf, cf.join());
cf =
runAsync(
() -> {
throw new RuntimeException();
});
checkCompletedExceptionally(cf);
cf =
runAsync(
() -> {
throw new RuntimeException();
},
commonPool());
checkCompletedExceptionally(cf);
cf =
runAsync(
() -> {
throw new RuntimeException();
},
executor);
checkCompletedExceptionally(cf);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// explicit completion
// ----------------------------------------------------------------
try {
final Phaser phaser = new Phaser(1);
final int phase = phaser.getPhase();
CompletableFuture<Integer> cf;
cf =
supplyAsync(
() -> {
phaser.awaitAdvance(phase);
return 1;
});
cf.complete(2);
phaser.arrive();
checkCompletedNormally(cf, 2);
cf =
supplyAsync(
() -> {
phaser.awaitAdvance(phase + 1);
return 1;
});
cf.completeExceptionally(new Throwable());
phaser.arrive();
checkCompletedExceptionally(cf);
cf =
supplyAsync(
() -> {
phaser.awaitAdvance(phase + 2);
return 1;
});
cf.cancel(true);
phaser.arrive();
checkCompletedExceptionally(cf, true);
cf =
supplyAsync(
() -> {
phaser.awaitAdvance(phase + 3);
return 1;
});
check(cf.getNow(2) == 2);
phaser.arrive();
checkCompletedNormally(cf, 1);
check(cf.getNow(2) == 1);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// thenApplyXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Integer> cf2;
CompletableFuture<String> cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenApply(
(x) -> {
if (x.equals("a test string")) return 1;
else return 0;
});
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, 1);
cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenApplyAsync(
(x) -> {
if (x.equals("a test string")) return 1;
else return 0;
});
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, 1);
cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenApplyAsync(
(x) -> {
if (x.equals("a test string")) return 1;
else return 0;
},
executor);
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, 1);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenApply(
(x) -> {
return 0;
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenApplyAsync(
(x) -> {
return 0;
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenApplyAsync(
(x) -> {
return 0;
},
executor);
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// thenAcceptXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf2;
int before = atomicInt.get();
CompletableFuture<String> cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenAccept(
(x) -> {
if (x.equals("a test string")) {
atomicInt.incrementAndGet();
return;
}
throw new RuntimeException();
});
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenAcceptAsync(
(x) -> {
if (x.equals("a test string")) {
atomicInt.incrementAndGet();
return;
}
throw new RuntimeException();
});
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenAcceptAsync(
(x) -> {
if (x.equals("a test string")) {
atomicInt.incrementAndGet();
return;
}
throw new RuntimeException();
},
executor);
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenAccept(
(x) -> {
atomicInt.incrementAndGet();
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenAcceptAsync(
(x) -> {
atomicInt.incrementAndGet();
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenAcceptAsync(
(x) -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// thenRunXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf2;
int before = atomicInt.get();
CompletableFuture<String> cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenRun(
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenRunAsync(
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> "a test string");
cf2 =
cf1.thenRunAsync(
() -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedNormally(cf1, "a test string");
checkCompletedNormally(cf2, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenRun(
() -> {
atomicInt.incrementAndGet();
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenRunAsync(
() -> {
atomicInt.incrementAndGet();
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenRunAsync(
() -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// thenCombineXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Integer> cf3;
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
CompletableFuture<Integer> cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenCombine(
cf2,
(x, y) -> {
return x + y;
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, 2);
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenCombineAsync(
cf2,
(x, y) -> {
return x + y;
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, 2);
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenCombineAsync(
cf2,
(x, y) -> {
return x + y;
},
executor);
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, 2);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenCombine(
cf2,
(x, y) -> {
return 0;
});
checkCompletedExceptionally(cf1);
checkCompletedNormally(cf2, 1);
checkCompletedExceptionally(cf3);
cf1 = supplyAsync(() -> 1);
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.thenCombineAsync(
cf2,
(x, y) -> {
return 0;
});
checkCompletedNormally(cf1, 1);
checkCompletedExceptionally(cf2);
checkCompletedExceptionally(cf3);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.thenCombineAsync(
cf2,
(x, y) -> {
return 0;
},
executor);
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
checkCompletedExceptionally(cf3);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// thenAcceptBothXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf3;
int before = atomicInt.get();
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
CompletableFuture<Integer> cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenAcceptBoth(
cf2,
(x, y) -> {
check(x + y == 2);
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenAcceptBothAsync(
cf2,
(x, y) -> {
check(x + y == 2);
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenAcceptBothAsync(
cf2,
(x, y) -> {
check(x + y == 2);
atomicInt.incrementAndGet();
},
executor);
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 = supplyAsync(() -> 1);
cf3 =
cf1.thenAcceptBoth(
cf2,
(x, y) -> {
atomicInt.incrementAndGet();
});
checkCompletedExceptionally(cf1);
checkCompletedNormally(cf2, 1);
checkCompletedExceptionally(cf3);
check(atomicInt.get() == before);
cf1 = supplyAsync(() -> 1);
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.thenAcceptBothAsync(
cf2,
(x, y) -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf1, 1);
checkCompletedExceptionally(cf2);
checkCompletedExceptionally(cf3);
check(atomicInt.get() == before);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.thenAcceptBothAsync(
cf2,
(x, y) -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
checkCompletedExceptionally(cf3);
check(atomicInt.get() == before);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// runAfterBothXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf3;
int before = atomicInt.get();
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
CompletableFuture<Integer> cf2 = supplyAsync(() -> 1);
cf3 =
cf1.runAfterBoth(
cf2,
() -> {
check(cf1.isDone());
check(cf2.isDone());
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
checkCompletedNormally(cf3, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
CompletableFuture<Integer> cfa = supplyAsync(() -> 1);
CompletableFuture<Integer> cfb = supplyAsync(() -> 1);
cf3 =
cfa.runAfterBothAsync(
cfb,
() -> {
check(cfa.isDone());
check(cfb.isDone());
atomicInt.incrementAndGet();
});
checkCompletedNormally(cfa, 1);
checkCompletedNormally(cfb, 1);
checkCompletedNormally(cf3, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
CompletableFuture<Integer> cfx = supplyAsync(() -> 1);
CompletableFuture<Integer> cfy = supplyAsync(() -> 1);
cf3 =
cfy.runAfterBothAsync(
cfx,
() -> {
check(cfx.isDone());
check(cfy.isDone());
atomicInt.incrementAndGet();
},
executor);
checkCompletedNormally(cfx, 1);
checkCompletedNormally(cfy, 1);
checkCompletedNormally(cf3, null);
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
CompletableFuture<Integer> cf4 =
supplyAsync(
() -> {
throw new RuntimeException();
});
CompletableFuture<Integer> cf5 = supplyAsync(() -> 1);
cf3 =
cf5.runAfterBothAsync(
cf4,
() -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedExceptionally(cf4);
checkCompletedNormally(cf5, 1);
checkCompletedExceptionally(cf3);
check(atomicInt.get() == before);
before = atomicInt.get();
cf4 = supplyAsync(() -> 1);
cf5 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf5.runAfterBothAsync(
cf4,
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf4, 1);
checkCompletedExceptionally(cf5);
checkCompletedExceptionally(cf3);
check(atomicInt.get() == before);
before = atomicInt.get();
cf4 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf5 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf5.runAfterBoth(
cf4,
() -> {
atomicInt.incrementAndGet();
});
checkCompletedExceptionally(cf4);
checkCompletedExceptionally(cf5);
checkCompletedExceptionally(cf3);
check(atomicInt.get() == before);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// applyToEitherXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Integer> cf3;
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
CompletableFuture<Integer> cf2 = supplyAsync(() -> 2);
cf3 =
cf1.applyToEither(
cf2,
(x) -> {
check(x == 1 || x == 2);
return x;
});
checkCompletedNormally(cf3, new Object[] {1, 2});
check(cf1.isDone() || cf2.isDone());
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 2);
cf3 =
cf1.applyToEitherAsync(
cf2,
(x) -> {
check(x == 1 || x == 2);
return x;
});
checkCompletedNormally(cf3, new Object[] {1, 2});
check(cf1.isDone() || cf2.isDone());
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 2);
cf3 =
cf1.applyToEitherAsync(
cf2,
(x) -> {
check(x == 1 || x == 2);
return x;
},
executor);
checkCompletedNormally(cf3, new Object[] {1, 2});
check(cf1.isDone() || cf2.isDone());
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 = supplyAsync(() -> 2);
cf3 =
cf1.applyToEither(
cf2,
(x) -> {
check(x == 2);
return x;
});
try {
check(cf3.join() == 2);
} catch (CompletionException x) {
pass();
}
check(cf3.isDone());
check(cf1.isDone() || cf2.isDone());
cf1 = supplyAsync(() -> 1);
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.applyToEitherAsync(
cf2,
(x) -> {
check(x == 1);
return x;
});
try {
check(cf3.join() == 1);
} catch (CompletionException x) {
pass();
}
check(cf3.isDone());
check(cf1.isDone() || cf2.isDone());
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.applyToEitherAsync(
cf2,
(x) -> {
fail();
return x;
});
checkCompletedExceptionally(cf3);
check(cf1.isDone() || cf2.isDone());
final Phaser cf3Done = new Phaser(2);
cf1 =
supplyAsync(
() -> {
cf3Done.arriveAndAwaitAdvance();
return 1;
});
cf2 = supplyAsync(() -> 2);
cf3 =
cf1.applyToEither(
cf2,
(x) -> {
check(x == 2);
return x;
});
checkCompletedNormally(cf3, 2);
checkCompletedNormally(cf2, 2);
check(!cf1.isDone());
cf3Done.arrive();
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf3, 2);
cf1 = supplyAsync(() -> 1);
cf2 =
supplyAsync(
() -> {
cf3Done.arriveAndAwaitAdvance();
return 2;
});
cf3 =
cf1.applyToEitherAsync(
cf2,
(x) -> {
check(x == 1);
return x;
});
checkCompletedNormally(cf3, 1);
checkCompletedNormally(cf1, 1);
check(!cf2.isDone());
cf3Done.arrive();
checkCompletedNormally(cf2, 2);
checkCompletedNormally(cf3, 1);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// acceptEitherXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf3;
int before = atomicInt.get();
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
CompletableFuture<Integer> cf2 = supplyAsync(() -> 2);
cf3 =
cf1.acceptEither(
cf2,
(x) -> {
check(x == 1 || x == 2);
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf3, null);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 2);
cf3 =
cf1.acceptEitherAsync(
cf2,
(x) -> {
check(x == 1 || x == 2);
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf3, null);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = supplyAsync(() -> 1);
cf2 = supplyAsync(() -> 2);
cf3 =
cf2.acceptEitherAsync(
cf1,
(x) -> {
check(x == 1 || x == 2);
atomicInt.incrementAndGet();
},
executor);
checkCompletedNormally(cf3, null);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == (before + 1));
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 = supplyAsync(() -> 2);
cf3 =
cf2.acceptEitherAsync(
cf1,
(x) -> {
check(x == 2);
},
executor);
try {
check(cf3.join() == null);
} catch (CompletionException x) {
pass();
}
check(cf3.isDone());
check(cf1.isDone() || cf2.isDone());
cf1 = supplyAsync(() -> 1);
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf2.acceptEitherAsync(
cf1,
(x) -> {
check(x == 1);
});
try {
check(cf3.join() == null);
} catch (CompletionException x) {
pass();
}
check(cf3.isDone());
check(cf1.isDone() || cf2.isDone());
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf2.acceptEitherAsync(
cf1,
(x) -> {
fail();
});
checkCompletedExceptionally(cf3);
check(cf1.isDone() || cf2.isDone());
final Phaser cf3Done = new Phaser(2);
cf1 =
supplyAsync(
() -> {
cf3Done.arriveAndAwaitAdvance();
return 1;
});
cf2 = supplyAsync(() -> 2);
cf3 =
cf1.acceptEither(
cf2,
(x) -> {
check(x == 2);
});
checkCompletedNormally(cf3, null);
checkCompletedNormally(cf2, 2);
check(!cf1.isDone());
cf3Done.arrive();
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf3, null);
cf1 = supplyAsync(() -> 1);
cf2 =
supplyAsync(
() -> {
cf3Done.arriveAndAwaitAdvance();
return 2;
});
cf3 =
cf1.acceptEitherAsync(
cf2,
(x) -> {
check(x == 1);
});
checkCompletedNormally(cf3, null);
checkCompletedNormally(cf1, 1);
check(!cf2.isDone());
cf3Done.arrive();
checkCompletedNormally(cf2, 2);
checkCompletedNormally(cf3, null);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// runAfterEitherXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Void> cf3;
int before = atomicInt.get();
CompletableFuture<Void> cf1 = runAsync(() -> {});
CompletableFuture<Void> cf2 = runAsync(() -> {});
cf3 =
cf1.runAfterEither(
cf2,
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf3, null);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = runAsync(() -> {});
cf2 = runAsync(() -> {});
cf3 =
cf1.runAfterEitherAsync(
cf2,
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf3, null);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 = runAsync(() -> {});
cf2 = runAsync(() -> {});
cf3 =
cf2.runAfterEitherAsync(
cf1,
() -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedNormally(cf3, null);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == (before + 1));
before = atomicInt.get();
cf1 =
runAsync(
() -> {
throw new RuntimeException();
});
cf2 = runAsync(() -> {});
cf3 =
cf2.runAfterEither(
cf1,
() -> {
atomicInt.incrementAndGet();
});
try {
check(cf3.join() == null);
check(atomicInt.get() == (before + 1));
} catch (CompletionException x) {
pass();
}
check(cf3.isDone());
check(cf1.isDone() || cf2.isDone());
before = atomicInt.get();
cf1 = runAsync(() -> {});
cf2 =
runAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf1.runAfterEitherAsync(
cf2,
() -> {
atomicInt.incrementAndGet();
});
try {
check(cf3.join() == null);
check(atomicInt.get() == (before + 1));
} catch (CompletionException x) {
pass();
}
check(cf3.isDone());
check(cf1.isDone() || cf2.isDone());
before = atomicInt.get();
cf1 =
runAsync(
() -> {
throw new RuntimeException();
});
cf2 =
runAsync(
() -> {
throw new RuntimeException();
});
cf3 =
cf2.runAfterEitherAsync(
cf1,
() -> {
atomicInt.incrementAndGet();
},
executor);
checkCompletedExceptionally(cf3);
check(cf1.isDone() || cf2.isDone());
check(atomicInt.get() == before);
final Phaser cf3Done = new Phaser(2);
before = atomicInt.get();
cf1 =
runAsync(
() -> {
cf3Done.arriveAndAwaitAdvance();
});
cf2 = runAsync(() -> {});
cf3 =
cf1.runAfterEither(
cf2,
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf3, null);
checkCompletedNormally(cf2, null);
check(!cf1.isDone());
check(atomicInt.get() == (before + 1));
cf3Done.arrive();
checkCompletedNormally(cf1, null);
checkCompletedNormally(cf3, null);
before = atomicInt.get();
cf1 = runAsync(() -> {});
cf2 =
runAsync(
() -> {
cf3Done.arriveAndAwaitAdvance();
});
cf3 =
cf1.runAfterEitherAsync(
cf2,
() -> {
atomicInt.incrementAndGet();
});
checkCompletedNormally(cf3, null);
checkCompletedNormally(cf1, null);
check(!cf2.isDone());
check(atomicInt.get() == (before + 1));
cf3Done.arrive();
checkCompletedNormally(cf2, null);
checkCompletedNormally(cf3, null);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// thenComposeXXX tests
// ----------------------------------------------------------------
try {
CompletableFuture<Integer> cf2;
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
cf2 =
cf1.thenCompose(
(x) -> {
check(x == 1);
return CompletableFuture.completedFuture(2);
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 2);
cf1 = supplyAsync(() -> 1);
cf2 =
cf1.thenComposeAsync(
(x) -> {
check(x == 1);
return CompletableFuture.completedFuture(2);
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 2);
cf1 = supplyAsync(() -> 1);
cf2 =
cf1.thenComposeAsync(
(x) -> {
check(x == 1);
return CompletableFuture.completedFuture(2);
},
executor);
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 2);
int before = atomicInt.get();
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenCompose(
(x) -> {
atomicInt.incrementAndGet();
return CompletableFuture.completedFuture(2);
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
cf1 =
supplyAsync(
() -> {
throw new RuntimeException();
});
cf2 =
cf1.thenComposeAsync(
(x) -> {
atomicInt.incrementAndGet();
return CompletableFuture.completedFuture(2);
});
checkCompletedExceptionally(cf1);
checkCompletedExceptionally(cf2);
check(atomicInt.get() == before);
cf1 = supplyAsync(() -> 1);
cf2 =
cf1.thenComposeAsync(
(x) -> {
throw new RuntimeException();
},
executor);
checkCompletedNormally(cf1, 1);
checkCompletedExceptionally(cf2);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// anyOf tests
// ----------------------------------------------------------------
try {
CompletableFuture<Object> cf3;
for (int k = 0; k < 10; k++) {
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
CompletableFuture<Integer> cf2 = supplyAsync(() -> 2);
cf3 = CompletableFuture.anyOf(cf1, cf2);
checkCompletedNormally(cf3, new Object[] {1, 2});
check(cf1.isDone() || cf2.isDone());
}
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// allOf tests
// ----------------------------------------------------------------
try {
CompletableFuture<?> cf3;
for (int k = 0; k < 10; k++) {
CompletableFuture<Integer>[] cfs =
(CompletableFuture<Integer>[]) Array.newInstance(CompletableFuture.class, 10);
for (int j = 0; j < 10; j++) {
final int v = j;
cfs[j] = supplyAsync(() -> v);
}
cf3 = CompletableFuture.allOf(cfs);
for (int j = 0; j < 10; j++) checkCompletedNormally(cfs[j], j);
checkCompletedNormally(cf3, null);
}
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// exceptionally tests
// ----------------------------------------------------------------
try {
CompletableFuture<Integer> cf2;
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
cf2 =
cf1.exceptionally(
(t) -> {
fail("function should never be called");
return 2;
});
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 1);
final RuntimeException t = new RuntimeException();
cf1 =
supplyAsync(
() -> {
throw t;
});
cf2 =
cf1.exceptionally(
(x) -> {
check(x.getCause() == t);
return 2;
});
checkCompletedExceptionally(cf1);
checkCompletedNormally(cf2, 2);
} catch (Throwable t) {
unexpected(t);
}
// ----------------------------------------------------------------
// handle tests
// ----------------------------------------------------------------
try {
CompletableFuture<Integer> cf2;
CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);
cf2 = cf1.handle((x, t) -> x + 1);
checkCompletedNormally(cf1, 1);
checkCompletedNormally(cf2, 2);
final RuntimeException ex = new RuntimeException();
cf1 =
supplyAsync(
() -> {
throw ex;
});
cf2 =
cf1.handle(
(x, t) -> {
check(t.getCause() == ex);
return 2;
});
checkCompletedExceptionally(cf1);
checkCompletedNormally(cf2, 2);
} catch (Throwable t) {
unexpected(t);
}
}
@Test
public void shouldConvertSuccessToCompletableFuture() {
CompletableFuture<String> future = success().toCompletableFuture();
assertThat(future.isDone());
assertThat(Try.of(future::get).get()).isEqualTo(success().get());
}
