Creating or failing a future will null should always return a failed …

…future - fixes #1426

src/main/java/io/vertx/core/Future.java

@@ -50,7 +50,7 @@ static <T> Future<T> future() {
    * @return  the future
    */
   static <T> Future<T> succeededFuture() {
-    return factory.completedFuture();
+    return factory.succeededFuture();
   }
 
   /**
@@ -61,7 +61,7 @@ static <T> Future<T> succeededFuture() {
    * @return  the future
    */
   static <T> Future<T> succeededFuture(T result) {
-    return factory.completedFuture(result);
+    return factory.succeededFuture(result);
   }
 
   /**
@@ -73,7 +73,7 @@ static <T> Future<T> succeededFuture(T result) {
    */
   @GenIgnore
   static <T> Future<T> failedFuture(Throwable t) {
-    return factory.completedFuture(t);
+    return factory.failedFuture(t);
   }
 
   /**
@@ -84,7 +84,7 @@ static <T> Future<T> failedFuture(Throwable t) {
    * @return  the future
    */
   static <T> Future<T> failedFuture(String failureMessage) {
-    return factory.completedFuture(failureMessage, true);
+    return factory.failureFuture(failureMessage);
   }
 
   /**

src/main/java/io/vertx/core/http/impl/HttpServerImpl.java

@@ -504,7 +504,8 @@ public int actualPort() {
 
   private void executeCloseDone(final ContextImpl closeContext, final Handler<AsyncResult<Void>> done, final Exception e) {
     if (done != null) {
-      closeContext.runOnContext((v) -> done.handle(Future.failedFuture(e)));
+      Future<Void> fut = e != null ? Future.failedFuture(e) : Future.succeededFuture();
+      closeContext.runOnContext((v) -> done.handle(fut));
     }
   }
 

src/main/java/io/vertx/core/impl/FutureFactoryImpl.java

@@ -31,22 +31,22 @@ public <T> Future<T> future() {
 
   // TODO - for completed futures with null values we could maybe reuse a static instance to save allocation
   @Override
-  public <T> Future<T> completedFuture() {
+  public <T> Future<T> succeededFuture() {
     return new FutureImpl<>((T)null);
   }
 
   @Override
-  public <T> Future<T> completedFuture(T result) {
+  public <T> Future<T> succeededFuture(T result) {
     return new FutureImpl<>(result);
   }
 
   @Override
-  public <T> Future<T> completedFuture(Throwable t) {
+  public <T> Future<T> failedFuture(Throwable t) {
     return new FutureImpl<>(t);
   }
 
   @Override
-  public <T> Future<T> completedFuture(String failureMessage, boolean failed) {
-    return new FutureImpl<>(failureMessage, true);
+  public <T> Future<T> failureFuture(String failureMessage) {
+    return new FutureImpl<>(failureMessage);
   }
 }

src/main/java/io/vertx/core/impl/FutureImpl.java

@@ -28,30 +28,30 @@ class FutureImpl<T> implements Future<T>, Handler<AsyncResult<T>> {
   private Throwable throwable;
 
   /**
-   * Create a FutureResult that hasn't completed yet
+   * Create a future that hasn't completed yet
    */
   FutureImpl() {
   }
 
   /**
-   * Create a VoidResult that has already completed
-   * @param t The Throwable or null if succeeded
+   * Create a future that has already failed
+   * @param t the throwable
    */
   FutureImpl(Throwable t) {
-    if (t == null) {
-      complete(null);
-    } else {
-      fail(t);
-    }
+    fail(t != null ? t : new NoStackTraceThrowable(null));
   }
 
-  FutureImpl(String failureMessage, boolean failed) {
+  /**
+   * Create a future that has already failed
+   * @param failureMessage the failure message
+   */
+  FutureImpl(String failureMessage) {
     this(new NoStackTraceThrowable(failureMessage));
   }
 
   /**
-   * Create a FutureResult that has already succeeded
-   * @param result The result
+   * Create a future that has already succeeded
+   * @param result the result
    */
   FutureImpl(T result) {
     complete(result);
@@ -143,7 +143,7 @@ public void handle(AsyncResult<T> ar) {
    */
   public void fail(Throwable throwable) {
     checkComplete();
-    this.throwable = throwable;
+    this.throwable = throwable != null ? throwable : new NoStackTraceThrowable(null);
     failed = true;
     checkCallHandler();
   }

src/main/java/io/vertx/core/net/impl/NetServerImpl.java

@@ -372,7 +372,8 @@ private void actualClose(ContextImpl closeContext, Handler<AsyncResult<Void>> do
 
   private void executeCloseDone(ContextImpl closeContext, Handler<AsyncResult<Void>> done, Exception e) {
     if (done != null) {
-      closeContext.runOnContext(v -> done.handle(Future.failedFuture(e)));
+      Future<Void> fut = e == null ? Future.succeededFuture() : Future.failedFuture(e);
+      closeContext.runOnContext(v -> done.handle(fut));
     }
   }
 

src/main/java/io/vertx/core/spi/FutureFactory.java

@@ -25,11 +25,11 @@ public interface FutureFactory {
 
   <T> Future<T> future();
 
-  <T> Future<T> completedFuture();
+  <T> Future<T> succeededFuture();
 
-  <T> Future<T> completedFuture(T result);
+  <T> Future<T> succeededFuture(T result);
 
-  <T> Future<T> completedFuture(Throwable t);
+  <T> Future<T> failedFuture(Throwable t);
 
-  <T> Future<T> completedFuture(String failureMessage, boolean failed);
+  <T> Future<T> failureFuture(String failureMessage);
 }

src/test/java/io/vertx/test/core/FutureTest.java

@@ -19,6 +19,7 @@
 import io.vertx.core.CompositeFuture;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
+import io.vertx.core.impl.NoStackTraceThrowable;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -185,6 +186,24 @@ public void testFailFutureToHandler() {
     assertEquals(cause, fut.cause());
   }
 
+
+  @Test
+  public void testCreateFailedWithNullFailure() {
+    Future<String> future = Future.failedFuture((Throwable)null);
+    Checker<String> checker = new Checker<>(future);
+    NoStackTraceThrowable failure = (NoStackTraceThrowable) checker.assertFailed();
+    assertNull(failure.getMessage());
+  }
+
+  @Test
+  public void testFailurFutureWithNullFailure() {
+    Future<String> future = Future.future();
+    future.fail((Throwable)null);
+    Checker<String> checker = new Checker<>(future);
+    NoStackTraceThrowable failure = (NoStackTraceThrowable) checker.assertFailed();
+    assertNull(failure.getMessage());
+  }
+
   @Test
   public void testAllSucceeded() {
     testAllSucceeded(CompositeFuture::all);
@@ -602,7 +621,7 @@ Throwable assertFailed() {
     }
   }
 
-/*
+  /*
   private <T> void assertSucceeded(Future<T> future, T expected) {
     assertTrue(future.isComplete());
     assertTrue(future.succeeded());