< prev index next >
test/jdk/java/util/concurrent/tck/CompletableFutureTest.java
Print this page
8211283: Miscellaneous changes imported from jsr166 CVS 2018-11
Reviewed-by: martin, chegar
*** 951,971 ****
public void testExceptionally_normalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.exceptionally
(f, (Throwable t) -> {
! threadFail("should not be called");
! return null; // unreached
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g, v1);
checkCompletedNormally(f, v1);
}}
/**
* exceptionally action completes with function value on source
* exception
--- 951,973 ----
public void testExceptionally_normalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
+ final AtomicInteger ran = new AtomicInteger(0);
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.exceptionally
(f, (Throwable t) -> {
! ran.getAndIncrement();
! throw new AssertionError("should not be called");
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g, v1);
checkCompletedNormally(f, v1);
+ assertEquals(0, ran.get());
}}
/**
* exceptionally action completes with function value on source
* exception
*** 973,1024 ****
public void testExceptionally_exceptionalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex);
final CompletableFuture<Integer> g = m.exceptionally
(f, (Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(t, ex);
! a.getAndIncrement();
return v1;
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedNormally(g, v1);
! assertEquals(1, a.get());
}}
/**
* If an "exceptionally action" throws an exception, it completes
* exceptionally with that exception
*/
public void testExceptionally_exceptionalCompletionActionFailed() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletableFuture<Integer> g = m.exceptionally
(f, (Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(t, ex1);
! a.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g, ex2);
checkCompletedExceptionally(f, ex1);
! assertEquals(1, a.get());
}}
/**
* whenComplete action executes on normal completion, propagating
* source result.
--- 975,1026 ----
public void testExceptionally_exceptionalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex);
final CompletableFuture<Integer> g = m.exceptionally
(f, (Throwable t) -> {
m.checkExecutionMode();
! assertSame(t, ex);
! ran.getAndIncrement();
return v1;
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedNormally(g, v1);
! assertEquals(1, ran.get());
}}
/**
* If an "exceptionally action" throws an exception, it completes
* exceptionally with that exception
*/
public void testExceptionally_exceptionalCompletionActionFailed() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletableFuture<Integer> g = m.exceptionally
(f, (Throwable t) -> {
m.checkExecutionMode();
! assertSame(t, ex1);
! ran.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g, ex2);
checkCompletedExceptionally(f, ex1);
! assertEquals(1, ran.get());
}}
/**
* whenComplete action executes on normal completion, propagating
* source result.
*** 1026,1078 ****
public void testWhenComplete_normalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger a = new AtomicInteger(0);
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(result, v1);
! threadAssertNull(t);
! a.getAndIncrement();
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g, v1);
checkCompletedNormally(f, v1);
! assertEquals(1, a.get());
}}
/**
* whenComplete action executes on exceptional completion, propagating
* source result.
*/
public void testWhenComplete_exceptionalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex);
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertNull(result);
! threadAssertSame(t, ex);
! a.getAndIncrement();
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedWithWrappedException(g, ex);
checkCompletedExceptionally(f, ex);
! assertEquals(1, a.get());
}}
/**
* whenComplete action executes on cancelled source, propagating
* CancellationException.
--- 1028,1080 ----
public void testWhenComplete_normalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertSame(result, v1);
! assertNull(t);
! ran.getAndIncrement();
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g, v1);
checkCompletedNormally(f, v1);
! assertEquals(1, ran.get());
}}
/**
* whenComplete action executes on exceptional completion, propagating
* source result.
*/
public void testWhenComplete_exceptionalCompletion() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex);
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertNull(result);
! assertSame(t, ex);
! ran.getAndIncrement();
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedWithWrappedException(g, ex);
checkCompletedExceptionally(f, ex);
! assertEquals(1, ran.get());
}}
/**
* whenComplete action executes on cancelled source, propagating
* CancellationException.
*** 1080,1105 ****
public void testWhenComplete_sourceCancelled() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean mayInterruptIfRunning : new boolean[] { true, false })
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger a = new AtomicInteger(0);
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertNull(result);
! threadAssertTrue(t instanceof CancellationException);
! a.getAndIncrement();
});
if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
checkCompletedWithWrappedCancellationException(g);
checkCancelled(f);
! assertEquals(1, a.get());
}}
/**
* If a whenComplete action throws an exception when triggered by
* a normal completion, it completes exceptionally
--- 1082,1107 ----
public void testWhenComplete_sourceCancelled() {
for (ExecutionMode m : ExecutionMode.values())
for (boolean mayInterruptIfRunning : new boolean[] { true, false })
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertNull(result);
! assertTrue(t instanceof CancellationException);
! ran.getAndIncrement();
});
if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
checkCompletedWithWrappedCancellationException(g);
checkCancelled(f);
! assertEquals(1, ran.get());
}}
/**
* If a whenComplete action throws an exception when triggered by
* a normal completion, it completes exceptionally
*** 1107,1134 ****
public void testWhenComplete_sourceCompletedNormallyActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
for (ExecutionMode m : ExecutionMode.values())
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(result, v1);
! threadAssertNull(t);
! a.getAndIncrement();
throw ex;
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedWithWrappedException(g, ex);
checkCompletedNormally(f, v1);
! assertEquals(1, a.get());
}}
/**
* If a whenComplete action throws an exception when triggered by
* a source completion that also throws an exception, the source
--- 1109,1136 ----
public void testWhenComplete_sourceCompletedNormallyActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
for (ExecutionMode m : ExecutionMode.values())
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertSame(result, v1);
! assertNull(t);
! ran.getAndIncrement();
throw ex;
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedWithWrappedException(g, ex);
checkCompletedNormally(f, v1);
! assertEquals(1, ran.get());
}}
/**
* If a whenComplete action throws an exception when triggered by
* a source completion that also throws an exception, the source
*** 1136,1169 ****
*/
public void testWhenComplete_sourceFailedActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
for (ExecutionMode m : ExecutionMode.values())
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(t, ex1);
! threadAssertNull(result);
! a.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g, ex1);
checkCompletedExceptionally(f, ex1);
if (testImplementationDetails) {
assertEquals(1, ex1.getSuppressed().length);
assertSame(ex2, ex1.getSuppressed()[0]);
}
! assertEquals(1, a.get());
}}
/**
* handle action completes normally with function value on normal
* completion of source
--- 1138,1171 ----
*/
public void testWhenComplete_sourceFailedActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
for (ExecutionMode m : ExecutionMode.values())
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletableFuture<Integer> g = m.whenComplete
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertSame(t, ex1);
! assertNull(result);
! ran.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g, ex1);
checkCompletedExceptionally(f, ex1);
if (testImplementationDetails) {
assertEquals(1, ex1.getSuppressed().length);
assertSame(ex2, ex1.getSuppressed()[0]);
}
! assertEquals(1, ran.get());
}}
/**
* handle action completes normally with function value on normal
* completion of source
*** 1172,1197 ****
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger a = new AtomicInteger(0);
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(result, v1);
! threadAssertNull(t);
! a.getAndIncrement();
return inc(v1);
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g, inc(v1));
checkCompletedNormally(f, v1);
! assertEquals(1, a.get());
}}
/**
* handle action completes normally with function value on
* exceptional completion of source
--- 1174,1199 ----
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger ran = new AtomicInteger(0);
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertSame(result, v1);
! assertNull(t);
! ran.getAndIncrement();
return inc(v1);
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g, inc(v1));
checkCompletedNormally(f, v1);
! assertEquals(1, ran.get());
}}
/**
* handle action completes normally with function value on
* exceptional completion of source
*** 1200,1226 ****
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex = new CFException();
if (!createIncomplete) f.completeExceptionally(ex);
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertNull(result);
! threadAssertSame(t, ex);
! a.getAndIncrement();
return v1;
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedNormally(g, v1);
checkCompletedExceptionally(f, ex);
! assertEquals(1, a.get());
}}
/**
* handle action completes normally with function value on
* cancelled source
--- 1202,1228 ----
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex = new CFException();
if (!createIncomplete) f.completeExceptionally(ex);
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertNull(result);
! assertSame(t, ex);
! ran.getAndIncrement();
return v1;
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedNormally(g, v1);
checkCompletedExceptionally(f, ex);
! assertEquals(1, ran.get());
}}
/**
* handle action completes normally with function value on
* cancelled source
*** 1230,1255 ****
for (boolean mayInterruptIfRunning : new boolean[] { true, false })
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger a = new AtomicInteger(0);
if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertNull(result);
! threadAssertTrue(t instanceof CancellationException);
! a.getAndIncrement();
return v1;
});
if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
checkCompletedNormally(g, v1);
checkCancelled(f);
! assertEquals(1, a.get());
}}
/**
* If a "handle action" throws an exception when triggered by
* a normal completion, it completes exceptionally
--- 1232,1257 ----
for (boolean mayInterruptIfRunning : new boolean[] { true, false })
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger ran = new AtomicInteger(0);
if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertNull(result);
! assertTrue(t instanceof CancellationException);
! ran.getAndIncrement();
return v1;
});
if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
checkCompletedNormally(g, v1);
checkCancelled(f);
! assertEquals(1, ran.get());
}}
/**
* If a "handle action" throws an exception when triggered by
* a normal completion, it completes exceptionally
*** 1258,1284 ****
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex = new CFException();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertSame(result, v1);
! threadAssertNull(t);
! a.getAndIncrement();
throw ex;
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedWithWrappedException(g, ex);
checkCompletedNormally(f, v1);
! assertEquals(1, a.get());
}}
/**
* If a "handle action" throws an exception when triggered by
* a source completion that also throws an exception, the action
--- 1260,1286 ----
for (ExecutionMode m : ExecutionMode.values())
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex = new CFException();
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertSame(result, v1);
! assertNull(t);
! ran.getAndIncrement();
throw ex;
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedWithWrappedException(g, ex);
checkCompletedNormally(f, v1);
! assertEquals(1, ran.get());
}}
/**
* If a "handle action" throws an exception when triggered by
* a source completion that also throws an exception, the action
*** 1286,1315 ****
*/
public void testHandle_sourceFailedActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
for (ExecutionMode m : ExecutionMode.values())
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! threadAssertNull(result);
! threadAssertSame(ex1, t);
! a.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g, ex2);
checkCompletedExceptionally(f, ex1);
! assertEquals(1, a.get());
}}
/**
* runAsync completes after running Runnable
*/
--- 1288,1317 ----
*/
public void testHandle_sourceFailedActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
for (ExecutionMode m : ExecutionMode.values())
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletableFuture<Integer> g = m.handle
(f,
(Integer result, Throwable t) -> {
m.checkExecutionMode();
! assertNull(result);
! assertSame(ex1, t);
! ran.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g, ex2);
checkCompletedExceptionally(f, ex1);
! assertEquals(1, ran.get());
}}
/**
* runAsync completes after running Runnable
*/
*** 3141,3174 ****
// Test all permutations of orders
switch (order) {
case 0:
assertTrue(f.complete(v1));
assertTrue(g.completeExceptionally(ex));
! h = m.thenCompose(f, (x -> g));
break;
case 1:
assertTrue(f.complete(v1));
! h = m.thenCompose(f, (x -> g));
assertTrue(g.completeExceptionally(ex));
break;
case 2:
assertTrue(g.completeExceptionally(ex));
assertTrue(f.complete(v1));
! h = m.thenCompose(f, (x -> g));
break;
case 3:
assertTrue(g.completeExceptionally(ex));
! h = m.thenCompose(f, (x -> g));
assertTrue(f.complete(v1));
break;
case 4:
! h = m.thenCompose(f, (x -> g));
assertTrue(f.complete(v1));
assertTrue(g.completeExceptionally(ex));
break;
case 5:
! h = m.thenCompose(f, (x -> g));
assertTrue(f.complete(v1));
assertTrue(g.completeExceptionally(ex));
break;
default: throw new AssertionError();
}
--- 3143,3176 ----
// Test all permutations of orders
switch (order) {
case 0:
assertTrue(f.complete(v1));
assertTrue(g.completeExceptionally(ex));
! h = m.thenCompose(f, x -> g);
break;
case 1:
assertTrue(f.complete(v1));
! h = m.thenCompose(f, x -> g);
assertTrue(g.completeExceptionally(ex));
break;
case 2:
assertTrue(g.completeExceptionally(ex));
assertTrue(f.complete(v1));
! h = m.thenCompose(f, x -> g);
break;
case 3:
assertTrue(g.completeExceptionally(ex));
! h = m.thenCompose(f, x -> g);
assertTrue(f.complete(v1));
break;
case 4:
! h = m.thenCompose(f, x -> g);
assertTrue(f.complete(v1));
assertTrue(g.completeExceptionally(ex));
break;
case 5:
! h = m.thenCompose(f, x -> g);
assertTrue(f.complete(v1));
assertTrue(g.completeExceptionally(ex));
break;
default: throw new AssertionError();
}
*** 3256,3289 ****
// Test all permutations of orders
switch (order) {
case 0:
assertTrue(f.completeExceptionally(ex0));
assertTrue(g.completeExceptionally(ex));
! h = m.exceptionallyCompose(f, (x -> g));
break;
case 1:
assertTrue(f.completeExceptionally(ex0));
! h = m.exceptionallyCompose(f, (x -> g));
assertTrue(g.completeExceptionally(ex));
break;
case 2:
assertTrue(g.completeExceptionally(ex));
assertTrue(f.completeExceptionally(ex0));
! h = m.exceptionallyCompose(f, (x -> g));
break;
case 3:
assertTrue(g.completeExceptionally(ex));
! h = m.exceptionallyCompose(f, (x -> g));
assertTrue(f.completeExceptionally(ex0));
break;
case 4:
! h = m.exceptionallyCompose(f, (x -> g));
assertTrue(f.completeExceptionally(ex0));
assertTrue(g.completeExceptionally(ex));
break;
case 5:
! h = m.exceptionallyCompose(f, (x -> g));
assertTrue(f.completeExceptionally(ex0));
assertTrue(g.completeExceptionally(ex));
break;
default: throw new AssertionError();
}
--- 3258,3291 ----
// Test all permutations of orders
switch (order) {
case 0:
assertTrue(f.completeExceptionally(ex0));
assertTrue(g.completeExceptionally(ex));
! h = m.exceptionallyCompose(f, x -> g);
break;
case 1:
assertTrue(f.completeExceptionally(ex0));
! h = m.exceptionallyCompose(f, x -> g);
assertTrue(g.completeExceptionally(ex));
break;
case 2:
assertTrue(g.completeExceptionally(ex));
assertTrue(f.completeExceptionally(ex0));
! h = m.exceptionallyCompose(f, x -> g);
break;
case 3:
assertTrue(g.completeExceptionally(ex));
! h = m.exceptionallyCompose(f, x -> g);
assertTrue(f.completeExceptionally(ex0));
break;
case 4:
! h = m.exceptionallyCompose(f, x -> g);
assertTrue(f.completeExceptionally(ex0));
assertTrue(g.completeExceptionally(ex));
break;
case 5:
! h = m.exceptionallyCompose(f, x -> g);
assertTrue(f.completeExceptionally(ex0));
assertTrue(g.completeExceptionally(ex));
break;
default: throw new AssertionError();
}
*** 3670,3685 ****
final CountingRejectingExecutor e = new CountingRejectingExecutor();
final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
- List<CompletableFuture<?>> futures = new ArrayList<>();
-
- List<CompletableFuture<Integer>> srcs = new ArrayList<>();
- srcs.add(complete);
- srcs.add(incomplete);
-
List<CompletableFuture<?>> fs = new ArrayList<>();
fs.add(incomplete.thenRunAsync(() -> {}, e));
fs.add(incomplete.thenAcceptAsync(z -> {}, e));
fs.add(incomplete.thenApplyAsync(z -> z, e));
--- 3672,3681 ----
*** 4860,4936 ****
*/
public void testDefaultExceptionallyAsync_normalCompletion() {
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
final CompletableFuture<Integer> f = new CompletableFuture<>();
final DelegatedCompletionStage<Integer> d =
new DelegatedCompletionStage<Integer>(f);
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletionStage<Integer> g = d.exceptionallyAsync
((Throwable t) -> {
! threadFail("should not be called");
! return null; // unreached
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g.toCompletableFuture(), v1);
}}
/**
* default-implemented exceptionallyAsync action completes with
* function value on source exception
*/
public void testDefaultExceptionallyAsync_exceptionalCompletion() {
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
final DelegatedCompletionStage<Integer> d =
new DelegatedCompletionStage<Integer>(f);
if (!createIncomplete) f.completeExceptionally(ex);
final CompletionStage<Integer> g = d.exceptionallyAsync
((Throwable t) -> {
! threadAssertSame(t, ex);
! a.getAndIncrement();
return v1;
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedNormally(g.toCompletableFuture(), v1);
! assertEquals(1, a.get());
}}
/**
* Under default implementation, if an "exceptionally action"
* throws an exception, it completes exceptionally with that
* exception
*/
public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger a = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
final DelegatedCompletionStage<Integer> d =
new DelegatedCompletionStage<Integer>(f);
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletionStage<Integer> g = d.exceptionallyAsync
((Throwable t) -> {
! threadAssertSame(t, ex1);
! a.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
checkCompletedExceptionally(f, ex1);
checkCompletedExceptionally(d.toCompletableFuture(), ex1);
! assertEquals(1, a.get());
}}
/**
* default-implemented exceptionallyCompose result completes
* normally after normal completion of source
--- 4856,4936 ----
*/
public void testDefaultExceptionallyAsync_normalCompletion() {
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
+ final AtomicInteger ran = new AtomicInteger(0);
final CompletableFuture<Integer> f = new CompletableFuture<>();
final DelegatedCompletionStage<Integer> d =
new DelegatedCompletionStage<Integer>(f);
if (!createIncomplete) assertTrue(f.complete(v1));
final CompletionStage<Integer> g = d.exceptionallyAsync
((Throwable t) -> {
! ran.getAndIncrement();
! throw new AssertionError("should not be called");
});
if (createIncomplete) assertTrue(f.complete(v1));
checkCompletedNormally(g.toCompletableFuture(), v1);
+ checkCompletedNormally(f, v1);
+ assertEquals(0, ran.get());
}}
/**
* default-implemented exceptionallyAsync action completes with
* function value on source exception
*/
public void testDefaultExceptionallyAsync_exceptionalCompletion() {
for (boolean createIncomplete : new boolean[] { true, false })
for (Integer v1 : new Integer[] { 1, null })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
final DelegatedCompletionStage<Integer> d =
new DelegatedCompletionStage<Integer>(f);
if (!createIncomplete) f.completeExceptionally(ex);
final CompletionStage<Integer> g = d.exceptionallyAsync
((Throwable t) -> {
! assertSame(t, ex);
! ran.getAndIncrement();
return v1;
});
if (createIncomplete) f.completeExceptionally(ex);
checkCompletedNormally(g.toCompletableFuture(), v1);
! checkCompletedExceptionally(f, ex);
! assertEquals(1, ran.get());
}}
/**
* Under default implementation, if an "exceptionally action"
* throws an exception, it completes exceptionally with that
* exception
*/
public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
for (boolean createIncomplete : new boolean[] { true, false })
{
! final AtomicInteger ran = new AtomicInteger(0);
final CFException ex1 = new CFException();
final CFException ex2 = new CFException();
final CompletableFuture<Integer> f = new CompletableFuture<>();
final DelegatedCompletionStage<Integer> d =
new DelegatedCompletionStage<Integer>(f);
if (!createIncomplete) f.completeExceptionally(ex1);
final CompletionStage<Integer> g = d.exceptionallyAsync
((Throwable t) -> {
! assertSame(t, ex1);
! ran.getAndIncrement();
throw ex2;
});
if (createIncomplete) f.completeExceptionally(ex1);
checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
checkCompletedExceptionally(f, ex1);
checkCompletedExceptionally(d.toCompletableFuture(), ex1);
! assertEquals(1, ran.get());
}}
/**
* default-implemented exceptionallyCompose result completes
* normally after normal completion of source
< prev index next >