@Test public void testToString() { assertEquals("Future{unresolved}", Future.future().toString()); assertEquals("Future{result=abc}", Future.succeededFuture("abc").toString()); assertEquals("Future{cause=It's like that, and that's the way it is}", Future.failedFuture("It's like that, and that's the way it is").toString()); Future<String> f = Future.future(); f.complete("abc"); assertEquals("Future{result=abc}", f.toString()); f = Future.future(); f.fail("abc"); assertEquals("Future{cause=abc}", f.toString()); }
@Test public void testCompositeFutureToList() { Future<String> f1 = Future.future(); Future<Integer> f2 = Future.future(); CompositeFuture composite = CompositeFuture.all(f1, f2); assertEquals(Arrays.asList(null, null), composite.list()); f1.complete("foo"); assertEquals(Arrays.asList("foo", null), composite.list()); f2.complete(4); assertEquals(Arrays.asList("foo", 4), composite.list()); }
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()); }
private void testAllFailed(BiFunction<Future<String>, Future<Integer>, CompositeFuture> all) { Future<String> f1 = Future.future(); Future<Integer> f2 = Future.future(); CompositeFuture composite = all.apply(f1, f2); Checker<CompositeFuture> checker = new Checker<>(composite); f1.complete("s"); Exception cause = new Exception(); f2.fail(cause); checker.assertFailed(cause); assertEquals("s", composite.resultAt(0)); assertEquals(null, composite.<Integer>resultAt(1)); }
@Test public void testSucceededAsyncResultMap() { Future<String> f = Future.future(); AsyncResult<String> res = asyncResult(f); AsyncResult<Integer> map1 = res.map(String::length); AsyncResult<Integer> map2 = res.map(17); f.complete("foobar"); assertEquals(6, (int)map1.result()); assertNull(map1.cause()); assertEquals(17, (int)map2.result()); assertNull(map2.cause()); }
private void testAllSucceeded(BiFunction<Future<String>, Future<Integer>, CompositeFuture> all) { Future<String> f1 = Future.future(); Future<Integer> f2 = Future.future(); CompositeFuture composite = all.apply(f1, f2); Checker<CompositeFuture> checker = new Checker<>(composite); checker.assertNotCompleted(); assertEquals(null, composite.<String>resultAt(0)); assertEquals(null, composite.<Integer>resultAt(1)); f1.complete("something"); checker.assertNotCompleted(); assertEquals("something", composite.resultAt(0)); assertEquals(null, composite.<Integer>resultAt(1)); f2.complete(3); checker.assertSucceeded(composite); assertEquals("something", composite.resultAt(0)); assertEquals(3, (int)composite.resultAt(1)); }
assertTrue(result.succeeded()); assertFalse(result.failed()); assertEquals(null, result.result()); assertEquals(null, result.cause()); called.set(true); }); assertTrue(result.succeeded()); assertFalse(result.failed()); assertEquals(foo, result.result()); assertEquals(null, result.cause()); called.set(true); }); assertFalse(result.succeeded()); assertTrue(result.failed()); assertEquals(null, result.result()); assertEquals(cause, result.cause()); called.set(true); });
private void testAnySucceeded1(BiFunction<Future<String>, Future<Integer>, CompositeFuture> any) { Future<String> f1 = Future.future(); Future<Integer> f2 = Future.future(); CompositeFuture composite = any.apply(f1, f2); Checker<CompositeFuture> checker = new Checker<>(composite); checker.assertNotCompleted(); assertEquals(null, composite.<String>resultAt(0)); assertEquals(null, composite.<Integer>resultAt(1)); f1.complete("something"); checker.assertSucceeded(composite); f2.complete(3); checker.assertSucceeded(composite); }
@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"); }
@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 testComposeFailsAfterCompletion() { Future<String> f1 = Future.future(); Future<Integer> f2 = Future.future(); Checker<Integer> checker = new Checker<>(f2); RuntimeException cause = new RuntimeException(); f1.compose(string -> { f2.complete(46); throw cause; }, f2); try { f1.complete("foo"); fail(); } catch (Exception e) { assertEquals(cause, e); } checker.assertSucceeded(46); }
@Test public void testComposeSuccessToSuccess() { Future<String> f1 = Future.future(); Future<Integer> f2 = Future.future(); Checker<Integer> checker = new Checker<>(f2); f1.compose(string -> f2.complete(string.length()), f2); checker.assertNotCompleted(); f1.complete("abcdef"); checker.assertSucceeded(6); AtomicReference<String> ref = new AtomicReference<>(); Future<Integer> c = Future.future(); Future<String> f3 = Future.future(); Future<Integer> f4 = f3.compose(string -> { ref.set(string); return c; }); checker = new Checker<>(f4); f3.complete("abcdef"); checker.assertNotCompleted(); assertEquals("abcdef", ref.get()); c.complete(6); checker.assertSucceeded(6); }
@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()); }