/*

 * 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */

/*

 * @test

 * @bug 8005696

 * @summary Basic tests for CompletableFuture

 * @author Chris Hegarty

 */

import java.lang.reflect.Array;

import java.util.concurrent.Phaser;

import static java.util.concurrent.TimeUnit.*;

import java.util.concurrent.CompletableFuture;

import static java.util.concurrent.CompletableFuture.*;

import java.util.concurrent.CompletionException;

import java.util.concurrent.CancellationException;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import static java.util.concurrent.ForkJoinPool.*;

import java.util.concurrent.atomic.AtomicInteger;

public class Basic {

    static void checkCompletedNormally(CompletableFuture<?> cf, Object value) {

        checkCompletedNormally(cf, value == null ? null : new Object[] { value });

    }

    static void checkCompletedNormally(CompletableFuture<?> cf, Object[] values) {

        try { equalAnyOf(cf.join(), values); } catch (Throwable x) { unexpected(x); }

        try { equalAnyOf(cf.getNow(null), values); } catch (Throwable x) { unexpected(x); }

        try { equalAnyOf(cf.get(), values); } catch (Throwable x) { unexpected(x); }

        try { equalAnyOf(cf.get(0L, SECONDS), values); } catch (Throwable x) { unexpected(x); }

        check(cf.isDone(), "Expected isDone to be true, got:" + cf);

        check(!cf.isCancelled(), "Expected isCancelled to be false");

        check(!cf.cancel(true), "Expected cancel to return false");

        check(cf.toString().contains("[Completed normally]"));

        check(cf.complete(null) == false, "Expected complete() to fail");

        check(cf.completeExceptionally(new Throwable()) == false,

              "Expected completeExceptionally() to fail");

    }

    static <T> void checkCompletedExceptionally(CompletableFuture<T> cf)

        throws Exception

    {

        checkCompletedExceptionally(cf, false);

    }

    @SuppressWarnings("unchecked")

    static <T> void checkCompletedExceptionally(CompletableFuture<T> cf, boolean cancelled)

        throws Exception

    {

        try { cf.join(); fail("Excepted exception to be thrown"); }

        catch (CompletionException x) { if (cancelled) fail(); else pass(); }

        catch (CancellationException x) { if (cancelled) pass(); else fail(); }

        try { cf.getNow(null); fail("Excepted exception to be thrown"); }

        catch (CompletionException x) { if (cancelled) fail(); else pass(); }

        catch (CancellationException x) { if (cancelled) pass(); else fail(); }

        try { cf.get(); fail("Excepted exception to be thrown");}

        catch (CancellationException x) { if (cancelled) pass(); else fail(); }

        catch (ExecutionException x) { if (cancelled) check(x.getCause() instanceof CancellationException); else pass(); }

        try { cf.get(0L, SECONDS); fail("Excepted exception to be thrown");}

        catch (CancellationException x) { if (cancelled) pass(); else fail(); }

        catch (ExecutionException x) { if (cancelled) check(x.getCause() instanceof CancellationException); else pass(); }

        check(cf.isDone(), "Expected isDone to be true, got:" + cf);

        check(cf.isCancelled() == cancelled, "Expected isCancelled: " + cancelled + ", got:"  + cf.isCancelled());

        check(cf.cancel(true) == cancelled, "Expected cancel: " + cancelled + ", got:"  + cf.cancel(true));

        check(cf.toString().contains("[Completed exceptionally]"));  // ## TODO: 'E'xceptionally

        check(cf.complete((T)new Object()) == false, "Expected complete() to fail");

        check(cf.completeExceptionally(new Throwable()) == false,

              "Expected completeExceptionally() to fail, already completed");

    }

    private static void realMain(String[] args) throws Throwable {

        ExecutorService executor = Executors.newFixedThreadPool(2);

        try {

            test(executor);

        } finally {

            executor.shutdown();

            executor.awaitTermination(30, SECONDS);

        }

    }

    static AtomicInteger atomicInt = new AtomicInteger(0);

    private static void test(ExecutorService executor) throws Throwable {

        Thread.currentThread().setName("mainThread");

        //----------------------------------------------------------------

        // supplyAsync tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<String> cf = supplyAsync(() -> "a test string");

            checkCompletedNormally(cf, cf.join());

            cf = supplyAsync(() -> "a test string", commonPool());

            checkCompletedNormally(cf, cf.join());

            cf = supplyAsync(() -> "a test string", executor);

            checkCompletedNormally(cf, cf.join());

            cf = supplyAsync(() -> { throw new RuntimeException(); });

            checkCompletedExceptionally(cf);

            cf = supplyAsync(() -> { throw new RuntimeException(); }, commonPool());

            checkCompletedExceptionally(cf);

            cf = supplyAsync(() -> { throw new RuntimeException(); }, executor);

            checkCompletedExceptionally(cf);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // runAsync tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Void> cf = runAsync(() -> { });

            checkCompletedNormally(cf, cf.join());

            cf = runAsync(() -> { }, commonPool());

            checkCompletedNormally(cf, cf.join());

            cf = runAsync(() -> { }, executor);

            checkCompletedNormally(cf, cf.join());

            cf = runAsync(() -> { throw new RuntimeException(); });

            checkCompletedExceptionally(cf);

            cf = runAsync(() -> { throw new RuntimeException(); }, commonPool());

            checkCompletedExceptionally(cf);

            cf = runAsync(() -> { throw new RuntimeException(); }, executor);

            checkCompletedExceptionally(cf);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // explicit completion

        //----------------------------------------------------------------

        try {

            final Phaser phaser = new Phaser(1);

            final int phase = phaser.getPhase();

            CompletableFuture<Integer> cf;

            cf = supplyAsync(() -> { phaser.awaitAdvance(phase); return 1; });

            cf.complete(2);

            phaser.arrive();

            checkCompletedNormally(cf, 2);

            cf = supplyAsync(() -> { phaser.awaitAdvance(phase+1); return 1; });

            cf.completeExceptionally(new Throwable());

            phaser.arrive();

            checkCompletedExceptionally(cf);

            cf = supplyAsync(() -> { phaser.awaitAdvance(phase+2); return 1; });

            cf.cancel(true);

            phaser.arrive();

            checkCompletedExceptionally(cf, true);

            cf = supplyAsync(() -> { phaser.awaitAdvance(phase+3); return 1; });

            check(cf.getNow(2) == 2);

            phaser.arrive();

            checkCompletedNormally(cf, 1);

            check(cf.getNow(2) == 1);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // thenApplyXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Integer> cf2;

            CompletableFuture<String> cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenApply((x) -> { if (x.equals("a test string")) return 1; else return 0; });

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, 1);

            cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenApplyAsync((x) -> { if (x.equals("a test string")) return 1; else return 0; });

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, 1);

            cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenApplyAsync((x) -> { if (x.equals("a test string")) return 1; else return 0; }, executor);

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, 1);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenApply((x) -> { return 0; } );

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenApplyAsync((x) -> { return 0; } );

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenApplyAsync((x) -> { return 0; }, executor);

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // thenAcceptXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Void> cf2;

            int before = atomicInt.get();

            CompletableFuture<String> cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenAccept((x) -> { if (x.equals("a test string")) { atomicInt.incrementAndGet(); return; } throw new RuntimeException(); });

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenAcceptAsync((x) -> { if (x.equals("a test string")) { atomicInt.incrementAndGet(); return; } throw new RuntimeException(); });

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenAcceptAsync((x) -> { if (x.equals("a test string")) { atomicInt.incrementAndGet(); return; } throw new RuntimeException(); }, executor);

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenAccept((x) -> { atomicInt.incrementAndGet(); } );

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            check(atomicInt.get() == before);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenAcceptAsync((x) -> { atomicInt.incrementAndGet(); } );

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            check(atomicInt.get() == before);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenAcceptAsync((x) -> { atomicInt.incrementAndGet(); }, executor );

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            check(atomicInt.get() == before);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // thenRunXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Void> cf2;

            int before = atomicInt.get();

            CompletableFuture<String> cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenRun(() -> { atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenRunAsync(() -> { atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> "a test string");

            cf2 = cf1.thenRunAsync(() -> { atomicInt.incrementAndGet(); }, executor);

            checkCompletedNormally(cf1, "a test string");

            checkCompletedNormally(cf2, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenRun(() -> { atomicInt.incrementAndGet(); });

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            check(atomicInt.get() == before);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenRunAsync(() -> { atomicInt.incrementAndGet(); });

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            check(atomicInt.get() == before);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = cf1.thenRunAsync(() -> { atomicInt.incrementAndGet(); }, executor);

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            check(atomicInt.get() == before);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // thenCombineXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Integer> cf3;

            CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);

            CompletableFuture<Integer> cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenCombine(cf2, (x, y) -> { return x + y; });

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, 2);

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenCombineAsync(cf2, (x, y) -> { return x + y; });

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, 2);

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenCombineAsync(cf2, (x, y) -> { return x + y; }, executor);

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, 2);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenCombine(cf2, (x, y) -> { return 0; });

            checkCompletedExceptionally(cf1);

            checkCompletedNormally(cf2, 1);

            checkCompletedExceptionally(cf3);

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf1.thenCombineAsync(cf2, (x, y) -> { return 0; });

            checkCompletedNormally(cf1, 1);

            checkCompletedExceptionally(cf2);

            checkCompletedExceptionally(cf3);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf1.thenCombineAsync(cf2, (x, y) -> { return 0; }, executor);

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            checkCompletedExceptionally(cf3);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // thenAcceptBothXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Void> cf3;

            int before = atomicInt.get();

            CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);

            CompletableFuture<Integer> cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenAcceptBoth(cf2, (x, y) -> { check(x + y == 2); atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenAcceptBothAsync(cf2, (x, y) -> { check(x + y == 2); atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenAcceptBothAsync(cf2, (x, y) -> { check(x + y == 2); atomicInt.incrementAndGet(); }, executor);

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = supplyAsync(() -> 1);

            cf3 = cf1.thenAcceptBoth(cf2, (x, y) -> { atomicInt.incrementAndGet(); });

            checkCompletedExceptionally(cf1);

            checkCompletedNormally(cf2, 1);

            checkCompletedExceptionally(cf3);

            check(atomicInt.get() == before);

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf1.thenAcceptBothAsync(cf2, (x, y) -> { atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf1, 1);

            checkCompletedExceptionally(cf2);

            checkCompletedExceptionally(cf3);

            check(atomicInt.get() == before);

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf1.thenAcceptBothAsync(cf2, (x, y) -> { atomicInt.incrementAndGet(); }, executor);

            checkCompletedExceptionally(cf1);

            checkCompletedExceptionally(cf2);

            checkCompletedExceptionally(cf3);

            check(atomicInt.get() == before);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // runAfterBothXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Void> cf3;

            int before = atomicInt.get();

            CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);

            CompletableFuture<Integer> cf2 = supplyAsync(() -> 1);

            cf3 = cf1.runAfterBoth(cf2, () -> { check(cf1.isDone()); check(cf2.isDone()); atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf1, 1);

            checkCompletedNormally(cf2, 1);

            checkCompletedNormally(cf3, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            CompletableFuture<Integer> cfa = supplyAsync(() -> 1);

            CompletableFuture<Integer> cfb = supplyAsync(() -> 1);

            cf3 = cfa.runAfterBothAsync(cfb, () -> { check(cfa.isDone()); check(cfb.isDone()); atomicInt.incrementAndGet(); });

            checkCompletedNormally(cfa, 1);

            checkCompletedNormally(cfb, 1);

            checkCompletedNormally(cf3, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            CompletableFuture<Integer> cfx = supplyAsync(() -> 1);

            CompletableFuture<Integer> cfy = supplyAsync(() -> 1);

            cf3 = cfy.runAfterBothAsync(cfx, () -> { check(cfx.isDone()); check(cfy.isDone()); atomicInt.incrementAndGet(); }, executor);

            checkCompletedNormally(cfx, 1);

            checkCompletedNormally(cfy, 1);

            checkCompletedNormally(cf3, null);

            check(atomicInt.get() == (before + 1));

            before = atomicInt.get();

            CompletableFuture<Integer> cf4 = supplyAsync(() -> { throw new RuntimeException(); });

            CompletableFuture<Integer> cf5 = supplyAsync(() -> 1);

            cf3 = cf5.runAfterBothAsync(cf4, () -> { atomicInt.incrementAndGet(); }, executor);

            checkCompletedExceptionally(cf4);

            checkCompletedNormally(cf5, 1);

            checkCompletedExceptionally(cf3);

            check(atomicInt.get() == before);

            before = atomicInt.get();

            cf4 = supplyAsync(() -> 1);

            cf5 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf5.runAfterBothAsync(cf4, () -> { atomicInt.incrementAndGet(); });

            checkCompletedNormally(cf4, 1);

            checkCompletedExceptionally(cf5);

            checkCompletedExceptionally(cf3);

            check(atomicInt.get() == before);

            before = atomicInt.get();

            cf4 = supplyAsync(() -> { throw new RuntimeException(); });

            cf5 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf5.runAfterBoth(cf4, () -> { atomicInt.incrementAndGet(); });

            checkCompletedExceptionally(cf4);

            checkCompletedExceptionally(cf5);

            checkCompletedExceptionally(cf3);

            check(atomicInt.get() == before);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // applyToEitherXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Integer> cf3;

            CompletableFuture<Integer> cf1 = supplyAsync(() -> 1);

            CompletableFuture<Integer> cf2 = supplyAsync(() -> 2);

            cf3 = cf1.applyToEither(cf2, (x) -> { check(x == 1 || x == 2); return x; });

            check(cf1.isDone() || cf2.isDone());

            checkCompletedNormally(cf3, new Object[] {1, 2});

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> 2);

            cf3 = cf1.applyToEitherAsync(cf2, (x) -> { check(x == 1 || x == 2); return x; });

            check(cf1.isDone() || cf2.isDone());

            checkCompletedNormally(cf3, new Object[] {1, 2});

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> 2);

            cf3 = cf1.applyToEitherAsync(cf2, (x) -> { check(x == 1 || x == 2); return x; }, executor);

            check(cf1.isDone() || cf2.isDone());

            checkCompletedNormally(cf3, new Object[] {1, 2});

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = supplyAsync(() -> 2);

            cf3 = cf1.applyToEither(cf2, (x) -> { check(x == 2); return x; });

            check(cf1.isDone() || cf2.isDone());

            try { check(cf3.join() == 1); } catch (CompletionException x) { pass(); }

            check(cf3.isDone());

            cf1 = supplyAsync(() -> 1);

            cf2 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf1.applyToEitherAsync(cf2, (x) -> { check(x == 1); return x; });

            check(cf1.isDone() || cf2.isDone());

            try { check(cf3.join() == 1); } catch (CompletionException x) { pass(); }

            check(cf3.isDone());

            cf1 = supplyAsync(() -> { throw new RuntimeException(); });

            cf2 = supplyAsync(() -> { throw new RuntimeException(); });

            cf3 = cf1.applyToEitherAsync(cf2, (x) -> { fail(); return x; });

            check(cf1.isDone() || cf2.isDone());

            checkCompletedExceptionally(cf3);

        } catch (Throwable t) { unexpected(t); }

        //----------------------------------------------------------------

        // acceptEitherXXX tests

        //----------------------------------------------------------------

        try {

            CompletableFuture<Void> cf3;