Fix Promise#allOf(Promise<?>...) (#881)

AllOfFuture completes with the list of values from each promise passed into its constructor. The varargs variant of Promise#allOf however has a return type of Void, so the intention seems to be to discard the results of the promises. Because a list of results is disjoint from Void any invocation of this method will throw an exception when the promises complete.

To resolve this we explicitly discard the result of the promises by mapping the result to null, the only possible value of Void.

Author: natemort

src/main/java/com/uber/cadence/internal/sync/WorkflowInternal.java

@@ -287,7 +287,7 @@ public static <U> Promise<List<U>> promiseAllOf(Collection<Promise<U>> promises)
 
   @SuppressWarnings("unchecked")
   public static Promise<Void> promiseAllOf(Promise<?>... promises) {
-    return new AllOfPromise(promises);
+    return new AllOfPromise(promises).thenApply(results -> null);
   }
 
   public static Promise<Object> promiseAnyOf(Iterable<Promise<?>> promises) {

src/test/java/com/uber/cadence/internal/sync/PromiseTest.java

@@ -20,6 +20,7 @@
 import static java.util.Collections.emptyList;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -439,6 +440,63 @@ public void testAllOf() throws Throwable {
     trace.setExpected(expected);
   }
 
+  @Test
+  public void testAllOf_varArgs() throws Throwable {
+    DeterministicRunner r =
+        DeterministicRunner.newRunner(
+            () -> {
+              trace.add("root begin");
+              CompletablePromise<String> f1 = Workflow.newPromise();
+              CompletablePromise<String> f2 = Workflow.newPromise();
+              CompletablePromise<String> f3 = Workflow.newPromise();
+
+              WorkflowInternal.newThread(
+                      false,
+                      () -> {
+                        trace.add("thread1 begin");
+                        f1.complete("value1");
+                        trace.add("thread1 done");
+                      })
+                  .start();
+              WorkflowInternal.newThread(
+                      false,
+                      () -> {
+                        trace.add("thread3 begin");
+                        f3.complete("value3");
+                        trace.add("thread3 done");
+                      })
+                  .start();
+              WorkflowInternal.newThread(
+                      false,
+                      () -> {
+                        trace.add("thread2 begin");
+                        f2.complete("value2");
+                        trace.add("thread2 done");
+                      })
+                  .start();
+
+              trace.add("root before allOf");
+              Promise<Void> all = Promise.allOf(f1, f2, f3);
+
+              assertNull(all.get());
+              trace.add("root done");
+            });
+    r.runUntilAllBlocked();
+    String[] expected =
+        new String[] {
+          "root begin",
+          "root before allOf",
+          "thread1 begin",
+          "thread1 done",
+          "thread3 begin",
+          "thread3 done",
+          "thread2 begin",
+          "thread2 done",
+          "root done"
+        };
+    trace.setExpected(expected);
+  }
+
   @Test
   public void testAllOf_shouldCompleteWithoutBlocking() throws Throwable {
     DeterministicRunner r =