simple completableFuture.exceptionally() not triggered when completing exceptionally()

I dont understand something basic.

public static void main(String[] args) {
    CompletableFuture<String> cf = new CompletableFuture<>();
    cf = cf.exceptionally(throwable ->  "inside exceptionally");

    cf.completeExceptionally(new IOException());
    String s = "im empty";
    try {
        s = cf.get();
    } catch (InterruptedException e) {
        System.out.println("inside InterruptedException catch");
    } catch (ExecutionException e) {
        System.out.println("inside ExecutionException catch");
    }
    System.out.println(s);
}

what i expected this code to output =

> inside exceptionally

the actual output:

> inside ExecutionException catch

> im empty

from the .exceptionally javadoc:

> Returns a new CompletableFuture that is completed when this CompletableFuture completes, with the result of the given function of the exception triggering this CompletableFuture's completion when it completes exceptionally; otherwise, if this CompletableFuture completes normally, then the returned CompletableFuture also completes normally with the same value.

If so, why did the catch of the get triggered?
I assumed me completing it exceptionally will trigger the .exceptionally() method and give me a valid String response...

What am I missing?

In this snippet

CompletableFuture<String> cf = new CompletableFuture<>();
cf = cf.exceptionally(throwable ->  "inside exceptionally");

you're creating a CompletableFuture that you later intend to complete and assigning its reference to cf. The exceptionally you then call returns a new CompletableFuture reference that you assign back to cf and causing you to lose the original.

When you later call

cf.completeExceptionally(new IOException());

you're doing so on the CompletableFuture returned by exceptionally, not the original. The original

CompletableFuture<String> cf = new CompletableFuture<>();

remains incomplete.

Finally, when you call

s = cf.get();

you're again doing so on the CompletableFuture returned by exceptionally, which was completed exceptionally with an IOException. You'll notice that if you call

e.getCause();

in that catch block, it'll contain that IOException.

You're chaining futures, but want to operate on both of them. You want to complete the original and get the result from the the one returned by exceptionally(). So store both of them in their own variables and do your thing. For example,

CompletableFuture<String> root = new CompletableFuture<>();
CompletableFuture<String> dependent = root.exceptionally(throwable -> "inside exceptionally");

root.completeExceptionally(new IOException());
String s = "im empty";
try {
    s = dependent.get();
} catch (InterruptedException e) {
    System.out.println("inside InterruptedException catch");
} catch (ExecutionException e) {
    System.out.println("inside ExecutionException catch");
}
System.out.println(s);

which will print

inside exceptionally

meaning the Function passed to exceptionally was executed when the root CompletableFuture was completed exceptionally.