- Incorporated gemini comments plus other improvements

- Added test cases

Author: eranl

sdk-platform-java/api-common-java/src/main/java/com/google/api/core/ApiFuture.java

@@ -30,6 +30,7 @@
 package com.google.api.core;
 
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Future;
 
@@ -45,13 +46,28 @@ default CompletableFuture<V> completable(Executor executor) {
     CompletableFuture<V> completableFuture = new CompletableFuture<>();
 
     addListener(() -> {
-      try {
-        completableFuture.complete(get());
-      } catch (Exception e) {
-        completableFuture.completeExceptionally(e);
+      if (isCancelled()) {
+        completableFuture.cancel(true);
+      } else {
+        try {
+          completableFuture.complete(get());
+        } catch (ExecutionException e) {
+          completableFuture.completeExceptionally(e.getCause() != null? e.getCause() : e);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          completableFuture.completeExceptionally(e);
+        } catch (Throwable t) {
+          completableFuture.completeExceptionally(t);
+        }
       }
     }, executor);
 
+    completableFuture.whenComplete((v, t) -> {
+      if (completableFuture.isCancelled()) {
+        cancel(true);
+      }
+    });
+
     return completableFuture;
   }
 }

sdk-platform-java/api-common-java/src/test/java/com/google/api/core/SettableApiFutureTest.java

@@ -30,9 +30,12 @@
 package com.google.api.core;
 
 import com.google.common.truth.Truth;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
 
@@ -93,7 +96,7 @@ public void execute(Runnable r) {
   }
 
   @Test
-  void testCompletable() {
+  void testCompletableApplied() {
     final AtomicInteger flag = new AtomicInteger();
     SettableApiFuture<Integer> future = SettableApiFuture.<Integer>create();
     future.completable(
@@ -113,4 +116,108 @@ public Object apply(Integer integer, Throwable throwable) {
     future.set(0);
     Truth.assertThat(flag.get()).isEqualTo(1);
   }
+
+  @Test
+  void testCompletableSuccess() throws Exception {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    Truth.assertThat(completable.isDone()).isFalse();
+    future.set(42);
+    Truth.assertThat(completable.isDone()).isTrue();
+    Truth.assertThat(completable.get()).isEqualTo(42);
+  }
+
+  @Test
+  void testCompletableException() {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    Exception expectedException = new IllegalArgumentException("something failed");
+    future.setException(expectedException);
+
+    Truth.assertThat(completable.isDone()).isTrue();
+    Truth.assertThat(completable.isCompletedExceptionally()).isTrue();
+    ExecutionException thrown =
+        Assertions.assertThrows(ExecutionException.class, completable::get);
+    Truth.assertThat(thrown.getCause()).isSameInstanceAs(expectedException);
+  }
+
+  @Test
+  void testCompletableCancelApiFutureCancelsCompletableFuture() {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    future.cancel(false);
+
+    Truth.assertThat(completable.isDone()).isTrue();
+    Truth.assertThat(completable.isCancelled()).isTrue();
+    Assertions.assertThrows(CancellationException.class, completable::get);
+  }
+
+  @Test
+  void testCompletableCancelCompletableFutureCancelsApiFuture() {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    completable.cancel(true);
+
+    Truth.assertThat(future.isDone()).isTrue();
+    Truth.assertThat(future.isCancelled()).isTrue();
+    Assertions.assertThrows(CancellationException.class, future::get);
+  }
+
+  @Test
+  void testCompletableAlreadyCompleted() throws Exception {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    future.set(100);
+
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    Truth.assertThat(completable.isDone()).isTrue();
+    Truth.assertThat(completable.get()).isEqualTo(100);
+  }
+
+  @Test
+  void testCompletableAlreadyFailed() {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    RuntimeException expectedException = new RuntimeException("pre-failed");
+    future.setException(expectedException);
+
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    Truth.assertThat(completable.isDone()).isTrue();
+    Truth.assertThat(completable.isCompletedExceptionally()).isTrue();
+    ExecutionException thrown =
+        Assertions.assertThrows(ExecutionException.class, completable::get);
+    Truth.assertThat(thrown.getCause()).isSameInstanceAs(expectedException);
+  }
+
+  @Test
+  void testCompletableAlreadyCancelled() {
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    future.cancel(false);
+
+    CompletableFuture<Integer> completable = future.completable(Runnable::run);
+
+    Truth.assertThat(completable.isDone()).isTrue();
+    Truth.assertThat(completable.isCancelled()).isTrue();
+  }
+
+  @Test
+  void testCompletableUsesExecutor() {
+    AtomicBoolean executorRan = new AtomicBoolean(false);
+    SettableApiFuture<Integer> future = SettableApiFuture.create();
+    CompletableFuture<Integer> completable =
+        future.completable(
+            command -> {
+              executorRan.set(true);
+              command.run();
+            });
+
+    Truth.assertThat(executorRan.get()).isFalse();
+    future.set(7);
+    Truth.assertThat(executorRan.get()).isTrue();
+    Truth.assertThat(completable.isDone()).isTrue();
+  }
 }