private void testFailedOtherwiseApplyFunction(AsyncResult<String> res, Future<String> f) { AsyncResult<String> map1 = res.otherwise(Throwable::getMessage); Throwable cause = new Throwable("the-failure"); f.fail(cause); assertTrue(map1.succeeded()); assertFalse(map1.failed()); assertEquals("the-failure", map1.result()); assertNull(map1.cause()); }
private void testFailedOtherwise(AsyncResult<String> res, Future<String> f) { AsyncResult<String> map1 = res.otherwise("something-else"); Throwable cause = new Throwable("the-failure"); f.fail(cause); assertTrue(map1.succeeded()); assertFalse(map1.failed()); assertEquals("something-else", map1.result()); assertNull(map1.cause()); }
private void testOtherwiseEmpty(AsyncResult<String> res, Future<String> f) { AsyncResult<String> otherwise = res.otherwiseEmpty(); Throwable cause = new Throwable("the-failure"); f.fail(cause); assertTrue(otherwise.succeeded()); assertFalse(otherwise.failed()); assertEquals(null, otherwise.result()); assertNull(otherwise.cause()); }
private void testSucceededOtherwiseApplyFunction(AsyncResult<String> res, Future<String> f) { AsyncResult<String> ar = res.otherwise("whatever"); f.complete("foobar"); assertTrue(ar.succeeded()); assertFalse(ar.failed()); assertEquals("foobar", ar.result()); assertNull(ar.cause()); }
private void testSucceededOtherwise(AsyncResult<String> res, Future<String> f) { AsyncResult<String> ar = res.otherwise(Throwable::getMessage); f.complete("foobar"); assertTrue(ar.succeeded()); assertFalse(ar.failed()); assertEquals("foobar", ar.result()); assertNull(ar.cause()); }
@Test public void testFailFutureToHandler() { Throwable cause = new Throwable(); Consumer<Handler<AsyncResult<String>>> consumer = handler -> { handler.handle(Future.failedFuture(cause)); }; Future<String> fut = Future.future(); consumer.accept(fut); assertTrue(fut.isComplete()); assertTrue(fut.failed()); assertEquals(cause, fut.cause()); }
@Test public void testResolveFutureToHandler() { Consumer<Handler<AsyncResult<String>>> consumer = handler -> { handler.handle(Future.succeededFuture("the-result")); }; Future<String> fut = Future.future(); consumer.accept(fut); assertTrue(fut.isComplete()); assertTrue(fut.succeeded()); assertEquals("the-result", fut.result()); }
@Test public void testAnyWithEmptyList() { CompositeFuture composite = CompositeFuture.any(Collections.emptyList()); assertTrue(composite.isComplete()); }
@Test public void testAllWithEmptyList() { CompositeFuture composite = CompositeFuture.all(Collections.emptyList()); assertTrue(composite.isComplete()); }
@Test public void testJoinWithEmptyList() { CompositeFuture composite = CompositeFuture.join(Collections.emptyList()); assertTrue(composite.isComplete()); }
Future<Object> future = Future.succeededFuture(); future.setHandler(result -> { assertTrue(result.succeeded()); assertFalse(result.failed()); assertEquals(null, result.result()); called.set(true); }); assertTrue(called.get()); called.set(false); Object foo = new Object(); future = Future.succeededFuture(foo); future.setHandler(result -> { assertTrue(result.succeeded()); assertFalse(result.failed()); assertEquals(foo, result.result()); called.set(true); }); assertTrue(called.get()); called.set(false); Exception cause = new Exception(); future.setHandler(result -> { assertFalse(result.succeeded()); assertTrue(result.failed()); assertEquals(null, result.result()); assertEquals(cause, result.cause()); called.set(true);
private void testAnyLargeList(int size) { List<Future> list = new ArrayList<>(); for (int i = 0;i < size;i++) { list.add(Future.failedFuture(new Exception())); } CompositeFuture composite = CompositeFuture.any(list); Checker<CompositeFuture> checker = new Checker<>(composite); checker.assertFailed(); for (int i = 0;i < size;i++) { list.clear(); for (int j = 0;j < size;j++) { list.add(i == j ? Future.succeededFuture() : Future.failedFuture(new RuntimeException())); } composite = CompositeFuture.any(list); checker = new Checker<>(composite); checker.assertSucceeded(composite); for (int j = 0;j < size;j++) { if (i == j) { assertTrue(composite.succeeded(j)); } else { assertTrue(composite.failed(j)); } } } }
@Test public void testSucceededFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> Future.succeededFuture(t.getMessage())); f.complete("yeah"); assertTrue(r.succeeded()); assertEquals(r.result(), "yeah"); }
@Test public void testFailedFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> Future.succeededFuture(t.getMessage())); f.fail("recovered"); assertTrue(r.succeeded()); assertEquals(r.result(), "recovered"); }
@Test public void testFailedMapperFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> { throw new RuntimeException("throw"); }); f.fail("recovered"); assertTrue(r.failed()); assertEquals(r.cause().getMessage(), "throw"); }
private void testAllLargeList(int size) { List<Future> list = new ArrayList<>(); for (int i = 0;i < size;i++) { list.add(Future.succeededFuture()); } CompositeFuture composite = CompositeFuture.all(list); Checker<CompositeFuture> checker = new Checker<>(composite); checker.assertSucceeded(composite); for (int i = 0;i < size;i++) { list.clear(); Throwable cause = new Exception(); for (int j = 0;j < size;j++) { list.add(i == j ? Future.failedFuture(cause) : Future.succeededFuture()); } composite = CompositeFuture.all(list); checker = new Checker<>(composite); checker.assertFailed(cause); for (int j = 0;j < size;j++) { if (i == j) { assertTrue(composite.failed(j)); } else { assertTrue(composite.succeeded(j)); } } } }
Future<Object> future = Future.future(); future.setHandler(result -> { assertTrue(result.succeeded()); assertFalse(result.failed()); assertEquals(null, result.result()); assertFalse(called.get()); future.complete(null); assertTrue(called.get()); called.set(false); Object foo = new Object(); future.setHandler(result -> { called.set(true); assertTrue(result.succeeded()); assertFalse(result.failed()); assertEquals(foo, result.result()); assertFalse(called.get()); future.complete(foo); assertTrue(called.get()); called.set(false); Exception cause = new Exception(); called.set(true); assertFalse(result.succeeded()); assertTrue(result.failed()); assertEquals(null, result.result()); assertEquals(cause, result.cause());
@Test public void testOtherwiseSuccessWithSuccess() { AtomicBoolean called = new AtomicBoolean(); Future<String> f = Future.future(); Future<String> r = f.otherwise(t -> { called.set(true); throw new AssertionError(); }); Checker<String> checker = new Checker<>(r); checker.assertNotCompleted(); f.complete("yeah"); assertTrue(r.succeeded()); checker.assertSucceeded("yeah"); assertFalse(called.get()); }
@Test public void testRecoverSuccessWithSuccess() { AtomicBoolean called = new AtomicBoolean(); Future<String> f = Future.future(); Future<String> r = f.recover(t -> { called.set(true); throw new AssertionError(); }); Checker<String> checker = new Checker<>(r); checker.assertNotCompleted(); f.complete("yeah"); assertTrue(r.succeeded()); checker.assertSucceeded("yeah"); assertFalse(called.get()); }
@Test public void testStateAfterCompletion() { Object foo = new Object(); Future<Object> future = Future.succeededFuture(foo); assertTrue(future.succeeded()); assertFalse(future.failed()); assertTrue(future.isComplete()); assertEquals(foo, future.result()); assertNull(future.cause()); Exception cause = new Exception(); future = Future.failedFuture(cause); assertFalse(future.succeeded()); assertTrue(future.failed()); assertTrue(future.isComplete()); assertNull(future.result()); assertEquals(cause, future.cause()); }