ThenComposeExceptionTest.java

/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiFunction;
import java.util.function.Consumer;

/**
 * @test
 * @bug 8068432 8072030
 * @run testng ThenComposeExceptionTest
 * @summary Test that CompletableFuture.thenCompose works correctly if the
 * composing future completes exceptionally
 */
@Test
public class ThenComposeExceptionTest {

    static final BiFunction<CompletableFuture<String>, CompletableFuture<String>, CompletableFuture<String>>
            THEN_COMPOSE = (f, fe) -> f.thenCompose(s -> fe);

    static final BiFunction<CompletableFuture<String>, CompletableFuture<String>, CompletableFuture<String>>
            THEN_COMPOSE_ASYNC = (f, fe) -> f.thenComposeAsync(s -> fe);

    static final Consumer<CompletableFuture<String>>
            COMPLETE_EXCEPTIONALLY = f -> f.completeExceptionally(new RuntimeException());

    static final Consumer<CompletableFuture<String>>
            NOP = f -> { };

    static Object[][] actionsDataProvider;

    @DataProvider(name = "actions")
    static Object[][] actionsDataProvider() {
        if (actionsDataProvider != null) {
            return actionsDataProvider;
        }

        List<Object[]> data = new ArrayList<>();
        data.add(new Object[]{"thenCompose and completeExceptionally", NOP, THEN_COMPOSE, COMPLETE_EXCEPTIONALLY});
        data.add(new Object[]{"thenComposeAsync and completeExceptionally", NOP, THEN_COMPOSE_ASYNC, COMPLETE_EXCEPTIONALLY});
        data.add(new Object[]{"completeExceptionally and thenCompose", COMPLETE_EXCEPTIONALLY, THEN_COMPOSE, NOP});
        data.add(new Object[]{"completeExceptionally and thenComposeAsync", COMPLETE_EXCEPTIONALLY, THEN_COMPOSE_ASYNC, NOP});

        return actionsDataProvider = data.toArray(new Object[0][]);
    }

    @Test(dataProvider = "actions")
    public void testThenCompose(
            String description,
            Consumer<CompletableFuture<String>> beforeAction,
            BiFunction<CompletableFuture<String>, CompletableFuture<String>, CompletableFuture<String>> composeFunction,
            Consumer<CompletableFuture<String>> afterAction) throws Exception {
        CompletableFuture<String> f = new CompletableFuture<>();
        CompletableFuture<String> fe = new CompletableFuture<>();

        // Ensure pre-composed stage is completed to trigger
        // processing the composing future
        f.complete("");

        beforeAction.accept(fe);

        CompletableFuture<String> f_thenCompose = composeFunction.apply(f, fe);
        Assert.assertNotSame(f_thenCompose, fe, "Composed CompletableFuture returned directly");

        AtomicReference<Throwable> eOnWhenComplete = new AtomicReference<>();
        CompletableFuture<String> f_whenComplete = f_thenCompose.
                whenComplete((r, e) -> eOnWhenComplete.set(e));

        afterAction.accept(fe);

        Throwable eOnJoined = null;
        try {
            f_thenCompose.join();
        }
        catch (Throwable t) {
            eOnJoined = t;
        }
        Assert.assertTrue(eOnJoined instanceof CompletionException,
                          "Incorrect exception reported when joined on thenCompose: " + eOnJoined);

        // Need to wait for f_whenComplete to complete to avoid
        // race condition when updating eOnWhenComplete
        eOnJoined = null;
        try {
            f_whenComplete.join();
        } catch (Throwable t) {
            eOnJoined = t;
        }
        Assert.assertTrue(eOnJoined instanceof CompletionException,
                          "Incorrect exception reported when joined on whenComplete: " + eOnJoined);
        Assert.assertTrue(eOnWhenComplete.get() instanceof CompletionException,
                          "Incorrect exception passed to whenComplete: " + eOnWhenComplete.get());
    }
}