ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java
(Generate patch)

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.36 by jsr166, Sun Jun 1 23:12:45 2014 UTC vs.
Revision 1.67 by jsr166, Fri Jun 6 19:25:41 2014 UTC

# Line 17 | Line 17 | import java.util.concurrent.Future;
17   import java.util.concurrent.CompletableFuture;
18   import java.util.concurrent.CompletionException;
19   import java.util.concurrent.CompletionStage;
20 + import java.util.concurrent.ForkJoinPool;
21 + import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.TimeoutException;
23   import java.util.concurrent.atomic.AtomicInteger;
24   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 247 | Line 249 | public class CompletableFutureTest exten
249          f = new CompletableFuture<>();
250          f.obtrudeValue(three);
251          checkCompletedNormally(f, three);
252 +        f.obtrudeValue(null);
253 +        checkCompletedNormally(f, null);
254          f = new CompletableFuture<>();
255          f.completeExceptionally(new CFException());
256          f.obtrudeValue(four);
# Line 279 | Line 283 | public class CompletableFutureTest exten
283       */
284      public void testGetNumberOfDependents() {
285          CompletableFuture<Integer> f = new CompletableFuture<>();
286 <        assertEquals(f.getNumberOfDependents(), 0);
287 <        CompletableFuture g = f.thenRun(new Noop());
288 <        assertEquals(f.getNumberOfDependents(), 1);
289 <        assertEquals(g.getNumberOfDependents(), 0);
290 <        CompletableFuture h = f.thenRun(new Noop());
291 <        assertEquals(f.getNumberOfDependents(), 2);
286 >        assertEquals(0, f.getNumberOfDependents());
287 >        CompletableFuture g = f.thenRun(new Noop(ExecutionMode.DEFAULT));
288 >        assertEquals(1, f.getNumberOfDependents());
289 >        assertEquals(0, g.getNumberOfDependents());
290 >        CompletableFuture h = f.thenRun(new Noop(ExecutionMode.DEFAULT));
291 >        assertEquals(2, f.getNumberOfDependents());
292          f.complete(1);
293          checkCompletedNormally(g, null);
294 <        assertEquals(f.getNumberOfDependents(), 0);
295 <        assertEquals(g.getNumberOfDependents(), 0);
294 >        assertEquals(0, f.getNumberOfDependents());
295 >        assertEquals(0, g.getNumberOfDependents());
296      }
297  
298      /**
# Line 316 | Line 320 | public class CompletableFutureTest exten
320          checkCompletedNormally(f, "test");
321      }
322  
323 <    // Choose non-commutative actions for better coverage
323 >    abstract class CheckedAction {
324 >        int invocationCount = 0;
325 >        final ExecutionMode m;
326 >        CheckedAction(ExecutionMode m) { this.m = m; }
327 >        void invoked() {
328 >            m.checkExecutionMode();
329 >            assertEquals(0, invocationCount++);
330 >        }
331 >        void assertNotInvoked() { assertEquals(0, invocationCount); }
332 >        void assertInvoked() { assertEquals(1, invocationCount); }
333 >    }
334 >
335 >    abstract class CheckedIntegerAction extends CheckedAction {
336 >        Integer value;
337 >        CheckedIntegerAction(ExecutionMode m) { super(m); }
338 >        void assertValue(Integer expected) {
339 >            assertInvoked();
340 >            assertEquals(expected, value);
341 >        }
342 >    }
343  
344 <    // A non-commutative function that handles null values as well
345 <    public static int subtract(Integer x, Integer y) {
346 <        return ((x == null) ? 42 : x.intValue())
344 >    class IntegerSupplier extends CheckedAction
345 >        implements Supplier<Integer>
346 >    {
347 >        final Integer value;
348 >        IntegerSupplier(ExecutionMode m, Integer value) {
349 >            super(m);
350 >            this.value = value;
351 >        }
352 >        public Integer get() {
353 >            invoked();
354 >            return value;
355 >        }
356 >    }
357 >
358 >    // A function that handles and produces null values as well.
359 >    static Integer inc(Integer x) {
360 >        return (x == null) ? null : x + 1;
361 >    }
362 >
363 >    class NoopConsumer extends CheckedIntegerAction
364 >        implements Consumer<Integer>
365 >    {
366 >        NoopConsumer(ExecutionMode m) { super(m); }
367 >        public void accept(Integer x) {
368 >            invoked();
369 >            value = x;
370 >        }
371 >    }
372 >
373 >    class IncFunction extends CheckedIntegerAction
374 >        implements Function<Integer,Integer>
375 >    {
376 >        IncFunction(ExecutionMode m) { super(m); }
377 >        public Integer apply(Integer x) {
378 >            invoked();
379 >            return value = inc(x);
380 >        }
381 >    }
382 >
383 >    // Choose non-commutative actions for better coverage
384 >    // A non-commutative function that handles and produces null values as well.
385 >    static Integer subtract(Integer x, Integer y) {
386 >        return (x == null && y == null) ? null :
387 >            ((x == null) ? 42 : x.intValue())
388              - ((y == null) ? 99 : y.intValue());
389      }
390  
391 <    static final Supplier<Integer> supplyOne =
392 <        () -> Integer.valueOf(1);
393 <    static final Function<Integer, Integer> inc =
394 <        (Integer x) -> Integer.valueOf(x.intValue() + 1);
331 <    static final BiFunction<Integer, Integer, Integer> subtract =
332 <        (Integer x, Integer y) -> subtract(x, y);
333 <    static final class IncAction implements Consumer<Integer> {
334 <        int value;
335 <        public void accept(Integer x) { value = x.intValue() + 1; }
336 <    }
337 <    static final class SubtractAction implements BiConsumer<Integer, Integer> {
338 <        volatile int invocationCount = 0;
339 <        int value;
340 <        // Check this action was invoked exactly once when result is computed.
341 <        public boolean ran() { return invocationCount == 1; }
391 >    class SubtractAction extends CheckedIntegerAction
392 >        implements BiConsumer<Integer, Integer>
393 >    {
394 >        SubtractAction(ExecutionMode m) { super(m); }
395          public void accept(Integer x, Integer y) {
396 <            invocationCount++;
396 >            invoked();
397              value = subtract(x, y);
398          }
399      }
400 <    static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
401 <        volatile int invocationCount = 0;
402 <        int value;
403 <        // Check this action was invoked exactly once when result is computed.
404 <        public boolean ran() { return invocationCount == 1; }
400 >
401 >    class SubtractFunction extends CheckedIntegerAction
402 >        implements BiFunction<Integer, Integer, Integer>
403 >    {
404 >        SubtractFunction(ExecutionMode m) { super(m); }
405          public Integer apply(Integer x, Integer y) {
406 <            invocationCount++;
407 <            return subtract(x, y);
406 >            invoked();
407 >            return value = subtract(x, y);
408          }
409      }
410 <    static final class Noop implements Runnable {
411 <        boolean ran;
412 <        public void run() { ran = true; }
410 >
411 >    class Noop extends CheckedAction implements Runnable {
412 >        Noop(ExecutionMode m) { super(m); }
413 >        public void run() {
414 >            invoked();
415 >        }
416      }
417  
418 <    static final class FailingSupplier implements Supplier<Integer> {
419 <        boolean ran;
420 <        public Integer get() { ran = true; throw new CFException(); }
418 >    class FailingSupplier extends CheckedAction
419 >        implements Supplier<Integer>
420 >    {
421 >        FailingSupplier(ExecutionMode m) { super(m); }
422 >        public Integer get() {
423 >            invoked();
424 >            throw new CFException();
425 >        }
426      }
427 <    static final class FailingConsumer implements Consumer<Integer> {
428 <        boolean ran;
429 <        public void accept(Integer x) { ran = true; throw new CFException(); }
427 >
428 >    class FailingConsumer extends CheckedIntegerAction
429 >        implements Consumer<Integer>
430 >    {
431 >        FailingConsumer(ExecutionMode m) { super(m); }
432 >        public void accept(Integer x) {
433 >            invoked();
434 >            value = x;
435 >            throw new CFException();
436 >        }
437      }
438 <    static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
439 <        boolean ran;
440 <        public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
438 >
439 >    class FailingBiConsumer extends CheckedIntegerAction
440 >        implements BiConsumer<Integer, Integer>
441 >    {
442 >        FailingBiConsumer(ExecutionMode m) { super(m); }
443 >        public void accept(Integer x, Integer y) {
444 >            invoked();
445 >            value = subtract(x, y);
446 >            throw new CFException();
447 >        }
448      }
449 <    static final class FailingFunction implements Function<Integer, Integer> {
450 <        boolean ran;
451 <        public Integer apply(Integer x) { ran = true; throw new CFException(); }
449 >
450 >    class FailingFunction extends CheckedIntegerAction
451 >        implements Function<Integer, Integer>
452 >    {
453 >        FailingFunction(ExecutionMode m) { super(m); }
454 >        public Integer apply(Integer x) {
455 >            invoked();
456 >            value = x;
457 >            throw new CFException();
458 >        }
459      }
460 <    static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
461 <        boolean ran;
462 <        public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
460 >
461 >    class FailingBiFunction extends CheckedIntegerAction
462 >        implements BiFunction<Integer, Integer, Integer>
463 >    {
464 >        FailingBiFunction(ExecutionMode m) { super(m); }
465 >        public Integer apply(Integer x, Integer y) {
466 >            invoked();
467 >            value = subtract(x, y);
468 >            throw new CFException();
469 >        }
470      }
471 <    static final class FailingNoop implements Runnable {
472 <        boolean ran;
473 <        public void run() { ran = true; throw new CFException(); }
471 >
472 >    class FailingRunnable extends CheckedAction implements Runnable {
473 >        FailingRunnable(ExecutionMode m) { super(m); }
474 >        public void run() {
475 >            invoked();
476 >            throw new CFException();
477 >        }
478      }
479  
480 <    static final class CompletableFutureInc
481 <        implements Function<Integer, CompletableFuture<Integer>> {
482 <        boolean ran;
480 >
481 >    class CompletableFutureInc extends CheckedIntegerAction
482 >        implements Function<Integer, CompletableFuture<Integer>>
483 >    {
484 >        CompletableFutureInc(ExecutionMode m) { super(m); }
485          public CompletableFuture<Integer> apply(Integer x) {
486 <            ran = true;
486 >            invoked();
487 >            value = x;
488              CompletableFuture<Integer> f = new CompletableFuture<>();
489 <            f.complete(Integer.valueOf(x.intValue() + 1));
489 >            f.complete(inc(x));
490              return f;
491          }
492      }
493  
494 <    static final class FailingCompletableFutureFunction
495 <        implements Function<Integer, CompletableFuture<Integer>> {
496 <        boolean ran;
494 >    class FailingCompletableFutureFunction extends CheckedIntegerAction
495 >        implements Function<Integer, CompletableFuture<Integer>>
496 >    {
497 >        FailingCompletableFutureFunction(ExecutionMode m) { super(m); }
498          public CompletableFuture<Integer> apply(Integer x) {
499 <            ran = true; throw new CFException();
499 >            invoked();
500 >            value = x;
501 >            throw new CFException();
502          }
503      }
504  
505      // Used for explicit executor tests
506      static final class ThreadExecutor implements Executor {
507 <        AtomicInteger count = new AtomicInteger(0);
507 >        final AtomicInteger count = new AtomicInteger(0);
508 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
509 >        static boolean startedCurrentThread() {
510 >            return Thread.currentThread().getThreadGroup() == tg;
511 >        }
512  
513          public void execute(Runnable r) {
514              count.getAndIncrement();
515 <            new Thread(r).start();
413 <        }
414 <    }
415 <
416 <    static final class ExceptionToInteger implements Function<Throwable, Integer> {
417 <        public Integer apply(Throwable x) { return Integer.valueOf(3); }
418 <    }
419 <
420 <    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
421 <        boolean ran;
422 <        public Integer apply(Integer x, Throwable t) {
423 <            ran = true;
424 <            return (t == null) ? two : three;
515 >            new Thread(tg, r).start();
516          }
517      }
518  
519      /**
520       * Permits the testing of parallel code for the 3 different
521 <     * execution modes without repeating all the testing code.
521 >     * execution modes without copy/pasting all the test methods.
522       */
523      enum ExecutionMode {
524          DEFAULT {
525 +            public void checkExecutionMode() {
526 +                assertFalse(ThreadExecutor.startedCurrentThread());
527 +                assertNull(ForkJoinTask.getPool());
528 +            }
529 +            public CompletableFuture<Void> runAsync(Runnable a) {
530 +                throw new UnsupportedOperationException();
531 +            }
532 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
533 +                throw new UnsupportedOperationException();
534 +            }
535 +            public <T> CompletableFuture<Void> thenRun
536 +                (CompletableFuture<T> f, Runnable a) {
537 +                return f.thenRun(a);
538 +            }
539 +            public <T> CompletableFuture<Void> thenAccept
540 +                (CompletableFuture<T> f, Consumer<? super T> a) {
541 +                return f.thenAccept(a);
542 +            }
543 +            public <T,U> CompletableFuture<U> thenApply
544 +                (CompletableFuture<T> f, Function<? super T,U> a) {
545 +                return f.thenApply(a);
546 +            }
547 +            public <T,U> CompletableFuture<U> thenCompose
548 +                (CompletableFuture<T> f,
549 +                 Function<? super T,? extends CompletionStage<U>> a) {
550 +                return f.thenCompose(a);
551 +            }
552 +            public <T,U> CompletableFuture<U> handle
553 +                (CompletableFuture<T> f,
554 +                 BiFunction<? super T,Throwable,? extends U> a) {
555 +                return f.handle(a);
556 +            }
557 +            public <T> CompletableFuture<T> whenComplete
558 +                (CompletableFuture<T> f,
559 +                 BiConsumer<? super T,? super Throwable> a) {
560 +                return f.whenComplete(a);
561 +            }
562              public <T,U> CompletableFuture<Void> runAfterBoth
563                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
564                  return f.runAfterBoth(g, a);
# Line 447 | Line 575 | public class CompletableFutureTest exten
575                   BiFunction<? super T,? super U,? extends V> a) {
576                  return f.thenCombine(g, a);
577              }
578 +            public <T> CompletableFuture<Void> runAfterEither
579 +                (CompletableFuture<T> f,
580 +                 CompletionStage<?> g,
581 +                 java.lang.Runnable a) {
582 +                return f.runAfterEither(g, a);
583 +            }
584 +            public <T> CompletableFuture<Void> acceptEither
585 +                (CompletableFuture<T> f,
586 +                 CompletionStage<? extends T> g,
587 +                 Consumer<? super T> a) {
588 +                return f.acceptEither(g, a);
589 +            }
590 +            public <T,U> CompletableFuture<U> applyToEither
591 +                (CompletableFuture<T> f,
592 +                 CompletionStage<? extends T> g,
593 +                 Function<? super T,U> a) {
594 +                return f.applyToEither(g, a);
595 +            }
596          },
597  
598 < //             /** Experimental way to do more testing */
599 < //         REVERSE_DEFAULT {
600 < //             public <T,U> CompletableFuture<Void> runAfterBoth
601 < //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
602 < //                 return g.runAfterBoth(f, a);
603 < //             }
604 < //             public <T,U> CompletableFuture<Void> thenAcceptBoth
605 < //                 (CompletableFuture<T> f,
606 < //                  CompletionStage<? extends U> g,
607 < //                  BiConsumer<? super T,? super U> a) {
608 < //                 return DEFAULT.thenAcceptBoth(f, g, a);
609 < //             }
610 < //         },
611 <
612 <        DEFAULT_ASYNC {
598 >        ASYNC {
599 >            public void checkExecutionMode() {
600 >                assertSame(ForkJoinPool.commonPool(),
601 >                           ForkJoinTask.getPool());
602 >            }
603 >            public CompletableFuture<Void> runAsync(Runnable a) {
604 >                return CompletableFuture.runAsync(a);
605 >            }
606 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
607 >                return CompletableFuture.supplyAsync(a);
608 >            }
609 >            public <T> CompletableFuture<Void> thenRun
610 >                (CompletableFuture<T> f, Runnable a) {
611 >                return f.thenRunAsync(a);
612 >            }
613 >            public <T> CompletableFuture<Void> thenAccept
614 >                (CompletableFuture<T> f, Consumer<? super T> a) {
615 >                return f.thenAcceptAsync(a);
616 >            }
617 >            public <T,U> CompletableFuture<U> thenApply
618 >                (CompletableFuture<T> f, Function<? super T,U> a) {
619 >                return f.thenApplyAsync(a);
620 >            }
621 >            public <T,U> CompletableFuture<U> thenCompose
622 >                (CompletableFuture<T> f,
623 >                 Function<? super T,? extends CompletionStage<U>> a) {
624 >                return f.thenComposeAsync(a);
625 >            }
626 >            public <T,U> CompletableFuture<U> handle
627 >                (CompletableFuture<T> f,
628 >                 BiFunction<? super T,Throwable,? extends U> a) {
629 >                return f.handleAsync(a);
630 >            }
631 >            public <T> CompletableFuture<T> whenComplete
632 >                (CompletableFuture<T> f,
633 >                 BiConsumer<? super T,? super Throwable> a) {
634 >                return f.whenCompleteAsync(a);
635 >            }
636              public <T,U> CompletableFuture<Void> runAfterBoth
637                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
638                  return f.runAfterBothAsync(g, a);
# Line 480 | Line 649 | public class CompletableFutureTest exten
649                   BiFunction<? super T,? super U,? extends V> a) {
650                  return f.thenCombineAsync(g, a);
651              }
652 +            public <T> CompletableFuture<Void> runAfterEither
653 +                (CompletableFuture<T> f,
654 +                 CompletionStage<?> g,
655 +                 java.lang.Runnable a) {
656 +                return f.runAfterEitherAsync(g, a);
657 +            }
658 +            public <T> CompletableFuture<Void> acceptEither
659 +                (CompletableFuture<T> f,
660 +                 CompletionStage<? extends T> g,
661 +                 Consumer<? super T> a) {
662 +                return f.acceptEitherAsync(g, a);
663 +            }
664 +            public <T,U> CompletableFuture<U> applyToEither
665 +                (CompletableFuture<T> f,
666 +                 CompletionStage<? extends T> g,
667 +                 Function<? super T,U> a) {
668 +                return f.applyToEitherAsync(g, a);
669 +            }
670          },
671  
485 //         REVERSE_DEFAULT_ASYNC {
486 //             public <T,U> CompletableFuture<Void> runAfterBoth
487 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
488 //                 return f.runAfterBothAsync(g, a);
489 //             }
490 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
491 //                 (CompletableFuture<T> f,
492 //                  CompletionStage<? extends U> g,
493 //                  BiConsumer<? super T,? super U> a) {
494 //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
495 //             }
496 //         },
497
672          EXECUTOR {
673 +            public void checkExecutionMode() {
674 +                assertTrue(ThreadExecutor.startedCurrentThread());
675 +            }
676 +            public CompletableFuture<Void> runAsync(Runnable a) {
677 +                return CompletableFuture.runAsync(a, new ThreadExecutor());
678 +            }
679 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
680 +                return CompletableFuture.supplyAsync(a, new ThreadExecutor());
681 +            }
682 +            public <T> CompletableFuture<Void> thenRun
683 +                (CompletableFuture<T> f, Runnable a) {
684 +                return f.thenRunAsync(a, new ThreadExecutor());
685 +            }
686 +            public <T> CompletableFuture<Void> thenAccept
687 +                (CompletableFuture<T> f, Consumer<? super T> a) {
688 +                return f.thenAcceptAsync(a, new ThreadExecutor());
689 +            }
690 +            public <T,U> CompletableFuture<U> thenApply
691 +                (CompletableFuture<T> f, Function<? super T,U> a) {
692 +                return f.thenApplyAsync(a, new ThreadExecutor());
693 +            }
694 +            public <T,U> CompletableFuture<U> thenCompose
695 +                (CompletableFuture<T> f,
696 +                 Function<? super T,? extends CompletionStage<U>> a) {
697 +                return f.thenComposeAsync(a, new ThreadExecutor());
698 +            }
699 +            public <T,U> CompletableFuture<U> handle
700 +                (CompletableFuture<T> f,
701 +                 BiFunction<? super T,Throwable,? extends U> a) {
702 +                return f.handleAsync(a, new ThreadExecutor());
703 +            }
704 +            public <T> CompletableFuture<T> whenComplete
705 +                (CompletableFuture<T> f,
706 +                 BiConsumer<? super T,? super Throwable> a) {
707 +                return f.whenCompleteAsync(a, new ThreadExecutor());
708 +            }
709              public <T,U> CompletableFuture<Void> runAfterBoth
710                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
711                  return f.runAfterBothAsync(g, a, new ThreadExecutor());
# Line 512 | Line 722 | public class CompletableFutureTest exten
722                   BiFunction<? super T,? super U,? extends V> a) {
723                  return f.thenCombineAsync(g, a, new ThreadExecutor());
724              }
725 +            public <T> CompletableFuture<Void> runAfterEither
726 +                (CompletableFuture<T> f,
727 +                 CompletionStage<?> g,
728 +                 java.lang.Runnable a) {
729 +                return f.runAfterEitherAsync(g, a, new ThreadExecutor());
730 +            }
731 +            public <T> CompletableFuture<Void> acceptEither
732 +                (CompletableFuture<T> f,
733 +                 CompletionStage<? extends T> g,
734 +                 Consumer<? super T> a) {
735 +                return f.acceptEitherAsync(g, a, new ThreadExecutor());
736 +            }
737 +            public <T,U> CompletableFuture<U> applyToEither
738 +                (CompletableFuture<T> f,
739 +                 CompletionStage<? extends T> g,
740 +                 Function<? super T,U> a) {
741 +                return f.applyToEitherAsync(g, a, new ThreadExecutor());
742 +            }
743          };
744  
745 +        public abstract void checkExecutionMode();
746 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
747 +        public abstract <U> CompletableFuture<U> supplyAsync(Supplier<U> a);
748 +        public abstract <T> CompletableFuture<Void> thenRun
749 +            (CompletableFuture<T> f, Runnable a);
750 +        public abstract <T> CompletableFuture<Void> thenAccept
751 +            (CompletableFuture<T> f, Consumer<? super T> a);
752 +        public abstract <T,U> CompletableFuture<U> thenApply
753 +            (CompletableFuture<T> f, Function<? super T,U> a);
754 +        public abstract <T,U> CompletableFuture<U> thenCompose
755 +            (CompletableFuture<T> f,
756 +             Function<? super T,? extends CompletionStage<U>> a);
757 +        public abstract <T,U> CompletableFuture<U> handle
758 +            (CompletableFuture<T> f,
759 +             BiFunction<? super T,Throwable,? extends U> a);
760 +        public abstract <T> CompletableFuture<T> whenComplete
761 +            (CompletableFuture<T> f,
762 +             BiConsumer<? super T,? super Throwable> a);
763          public abstract <T,U> CompletableFuture<Void> runAfterBoth
764              (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
765          public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
# Line 524 | Line 770 | public class CompletableFutureTest exten
770              (CompletableFuture<T> f,
771               CompletionStage<? extends U> g,
772               BiFunction<? super T,? super U,? extends V> a);
773 +        public abstract <T> CompletableFuture<Void> runAfterEither
774 +            (CompletableFuture<T> f,
775 +             CompletionStage<?> g,
776 +             java.lang.Runnable a);
777 +        public abstract <T> CompletableFuture<Void> acceptEither
778 +            (CompletableFuture<T> f,
779 +             CompletionStage<? extends T> g,
780 +             Consumer<? super T> a);
781 +        public abstract <T,U> CompletableFuture<U> applyToEither
782 +            (CompletableFuture<T> f,
783 +             CompletionStage<? extends T> g,
784 +             Function<? super T,U> a);
785      }
786  
787      /**
788 +     * exceptionally action is not invoked when source completes
789 +     * normally, and source result is propagated
790 +     */
791 +    public void testExceptionally_normalCompletion() {
792 +        for (boolean createIncomplete : new boolean[] { true, false })
793 +        for (Integer v1 : new Integer[] { 1, null })
794 +    {
795 +        final AtomicInteger a = new AtomicInteger(0);
796 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
797 +        if (!createIncomplete) f.complete(v1);
798 +        final CompletableFuture<Integer> g = f.exceptionally
799 +            ((Throwable t) -> {
800 +                // Should not be called
801 +                a.getAndIncrement();
802 +                throw new AssertionError();
803 +            });
804 +        if (createIncomplete) f.complete(v1);
805 +
806 +        checkCompletedNormally(g, v1);
807 +        checkCompletedNormally(f, v1);
808 +        assertEquals(0, a.get());
809 +    }}
810 +
811 +
812 +    /**
813       * exceptionally action completes with function value on source
814 <     * exception; otherwise with source value
814 >     * exception
815       */
816 <    public void testExceptionally() {
817 <        CompletableFuture<Integer> f = new CompletableFuture<>();
818 <        ExceptionToInteger r = new ExceptionToInteger();
819 <        CompletableFuture<Integer> g = f.exceptionally(r);
820 <        f.completeExceptionally(new CFException());
821 <        checkCompletedNormally(g, three);
816 >    public void testExceptionally_exceptionalCompletion() {
817 >        for (boolean createIncomplete : new boolean[] { true, false })
818 >        for (Integer v1 : new Integer[] { 1, null })
819 >    {
820 >        final AtomicInteger a = new AtomicInteger(0);
821 >        final CFException ex = new CFException();
822 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
823 >        if (!createIncomplete) f.completeExceptionally(ex);
824 >        final CompletableFuture<Integer> g = f.exceptionally
825 >            ((Throwable t) -> {
826 >                ExecutionMode.DEFAULT.checkExecutionMode();
827 >                threadAssertSame(t, ex);
828 >                a.getAndIncrement();
829 >                return v1;
830 >            });
831 >        if (createIncomplete) f.completeExceptionally(ex);
832  
833 <        f = new CompletableFuture<>();
834 <        r = new ExceptionToInteger();
835 <        g = f.exceptionally(r);
836 <        f.complete(one);
837 <        checkCompletedNormally(g, one);
838 <    }
833 >        checkCompletedNormally(g, v1);
834 >        assertEquals(1, a.get());
835 >    }}
836 >
837 >    public void testExceptionally_exceptionalCompletionActionFailed() {
838 >        for (boolean createIncomplete : new boolean[] { true, false })
839 >        for (Integer v1 : new Integer[] { 1, null })
840 >    {
841 >        final AtomicInteger a = new AtomicInteger(0);
842 >        final CFException ex1 = new CFException();
843 >        final CFException ex2 = new CFException();
844 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
845 >        if (!createIncomplete) f.completeExceptionally(ex1);
846 >        final CompletableFuture<Integer> g = f.exceptionally
847 >            ((Throwable t) -> {
848 >                ExecutionMode.DEFAULT.checkExecutionMode();
849 >                threadAssertSame(t, ex1);
850 >                a.getAndIncrement();
851 >                throw ex2;
852 >            });
853 >        if (createIncomplete) f.completeExceptionally(ex1);
854 >
855 >        checkCompletedWithWrappedCFException(g, ex2);
856 >        assertEquals(1, a.get());
857 >    }}
858  
859      /**
860 <     * handle action completes normally with function value on either
861 <     * normal or exceptional completion of source
860 >     * handle action completes normally with function value on normal
861 >     * completion of source
862       */
863 <    public void testHandle() {
864 <        CompletableFuture<Integer> f, g;
865 <        IntegerHandler r;
863 >    public void testHandle_normalCompletion() {
864 >        for (ExecutionMode m : ExecutionMode.values())
865 >        for (boolean createIncomplete : new boolean[] { true, false })
866 >        for (Integer v1 : new Integer[] { 1, null })
867 >    {
868 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
869 >        final AtomicInteger a = new AtomicInteger(0);
870 >        if (!createIncomplete) f.complete(v1);
871 >        final CompletableFuture<Integer> g = m.handle
872 >            (f,
873 >             (Integer x, Throwable t) -> {
874 >                m.checkExecutionMode();
875 >                threadAssertSame(x, v1);
876 >                threadAssertNull(t);
877 >                a.getAndIncrement();
878 >                return inc(v1);
879 >            });
880 >        if (createIncomplete) f.complete(v1);
881  
882 <        f = new CompletableFuture<>();
883 <        f.completeExceptionally(new CFException());
884 <        g = f.handle(r = new IntegerHandler());
885 <        assertTrue(r.ran);
559 <        checkCompletedNormally(g, three);
882 >        checkCompletedNormally(g, inc(v1));
883 >        checkCompletedNormally(f, v1);
884 >        assertEquals(1, a.get());
885 >    }}
886  
887 <        f = new CompletableFuture<>();
888 <        g = f.handle(r = new IntegerHandler());
889 <        assertFalse(r.ran);
890 <        f.completeExceptionally(new CFException());
891 <        checkCompletedNormally(g, three);
892 <        assertTrue(r.ran);
887 >    /**
888 >     * handle action completes normally with function value on
889 >     * exceptional completion of source
890 >     */
891 >    public void testHandle_exceptionalCompletion() {
892 >        for (ExecutionMode m : ExecutionMode.values())
893 >        for (boolean createIncomplete : new boolean[] { true, false })
894 >        for (Integer v1 : new Integer[] { 1, null })
895 >    {
896 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
897 >        final AtomicInteger a = new AtomicInteger(0);
898 >        final CFException ex = new CFException();
899 >        if (!createIncomplete) f.completeExceptionally(ex);
900 >        final CompletableFuture<Integer> g = m.handle
901 >            (f,
902 >             (Integer x, Throwable t) -> {
903 >                m.checkExecutionMode();
904 >                threadAssertNull(x);
905 >                threadAssertSame(t, ex);
906 >                a.getAndIncrement();
907 >                return v1;
908 >            });
909 >        if (createIncomplete) f.completeExceptionally(ex);
910  
911 <        f = new CompletableFuture<>();
912 <        f.complete(one);
913 <        g = f.handle(r = new IntegerHandler());
914 <        assertTrue(r.ran);
572 <        checkCompletedNormally(g, two);
911 >        checkCompletedNormally(g, v1);
912 >        checkCompletedWithWrappedCFException(f, ex);
913 >        assertEquals(1, a.get());
914 >    }}
915  
916 <        f = new CompletableFuture<>();
917 <        g = f.handle(r = new IntegerHandler());
918 <        assertFalse(r.ran);
919 <        f.complete(one);
920 <        assertTrue(r.ran);
921 <        checkCompletedNormally(g, two);
922 <    }
916 >    /**
917 >     * handle action completes normally with function value on
918 >     * cancelled source
919 >     */
920 >    public void testHandle_sourceCancelled() {
921 >        for (ExecutionMode m : ExecutionMode.values())
922 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
923 >        for (boolean createIncomplete : new boolean[] { true, false })
924 >        for (Integer v1 : new Integer[] { 1, null })
925 >    {
926 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
927 >        final AtomicInteger a = new AtomicInteger(0);
928 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
929 >        final CompletableFuture<Integer> g = m.handle
930 >            (f,
931 >             (Integer x, Throwable t) -> {
932 >                m.checkExecutionMode();
933 >                threadAssertNull(x);
934 >                threadAssertTrue(t instanceof CancellationException);
935 >                a.getAndIncrement();
936 >                return v1;
937 >            });
938 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
939 >
940 >        checkCompletedNormally(g, v1);
941 >        checkCancelled(f);
942 >        assertEquals(1, a.get());
943 >    }}
944  
945      /**
946 <     * runAsync completes after running Runnable
946 >     * handle result completes exceptionally if action does
947       */
948 <    public void testRunAsync() {
949 <        Noop r = new Noop();
950 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
951 <        assertNull(f.join());
952 <        assertTrue(r.ran);
953 <        checkCompletedNormally(f, null);
954 <    }
948 >    public void testHandle_sourceFailedActionFailed() {
949 >        for (ExecutionMode m : ExecutionMode.values())
950 >        for (boolean createIncomplete : new boolean[] { true, false })
951 >    {
952 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
953 >        final AtomicInteger a = new AtomicInteger(0);
954 >        final CFException ex1 = new CFException();
955 >        final CFException ex2 = new CFException();
956 >        if (!createIncomplete) f.completeExceptionally(ex1);
957 >        final CompletableFuture<Integer> g = m.handle
958 >            (f,
959 >             (Integer x, Throwable t) -> {
960 >                m.checkExecutionMode();
961 >                threadAssertNull(x);
962 >                threadAssertSame(ex1, t);
963 >                a.getAndIncrement();
964 >                throw ex2;
965 >            });
966 >        if (createIncomplete) f.completeExceptionally(ex1);
967 >
968 >        checkCompletedWithWrappedCFException(g, ex2);
969 >        checkCompletedWithWrappedCFException(f, ex1);
970 >        assertEquals(1, a.get());
971 >    }}
972 >
973 >    public void testHandle_sourceCompletedNormallyActionFailed() {
974 >        for (ExecutionMode m : ExecutionMode.values())
975 >        for (boolean createIncomplete : new boolean[] { true, false })
976 >        for (Integer v1 : new Integer[] { 1, null })
977 >    {
978 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
979 >        final AtomicInteger a = new AtomicInteger(0);
980 >        final CFException ex = new CFException();
981 >        if (!createIncomplete) f.complete(v1);
982 >        final CompletableFuture<Integer> g = m.handle
983 >            (f,
984 >             (Integer x, Throwable t) -> {
985 >                m.checkExecutionMode();
986 >                threadAssertSame(x, v1);
987 >                threadAssertNull(t);
988 >                a.getAndIncrement();
989 >                throw ex;
990 >            });
991 >        if (createIncomplete) f.complete(v1);
992 >
993 >        checkCompletedWithWrappedCFException(g, ex);
994 >        checkCompletedNormally(f, v1);
995 >        assertEquals(1, a.get());
996 >    }}
997  
998      /**
999 <     * runAsync with executor completes after running Runnable
999 >     * runAsync completes after running Runnable
1000       */
1001 <    public void testRunAsync2() {
1002 <        Noop r = new Noop();
1003 <        ThreadExecutor exec = new ThreadExecutor();
1004 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
1001 >    public void testRunAsync_normalCompletion() {
1002 >        ExecutionMode[] executionModes = {
1003 >            ExecutionMode.ASYNC,
1004 >            ExecutionMode.EXECUTOR,
1005 >        };
1006 >        for (ExecutionMode m : executionModes)
1007 >    {
1008 >        final Noop r = new Noop(m);
1009 >        final CompletableFuture<Void> f = m.runAsync(r);
1010          assertNull(f.join());
601        assertTrue(r.ran);
1011          checkCompletedNormally(f, null);
1012 <        assertEquals(1, exec.count.get());
1013 <    }
1012 >        r.assertInvoked();
1013 >    }}
1014  
1015      /**
1016       * failing runAsync completes exceptionally after running Runnable
1017       */
1018 <    public void testRunAsync3() {
1019 <        FailingNoop r = new FailingNoop();
1020 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
1018 >    public void testRunAsync_exceptionalCompletion() {
1019 >        ExecutionMode[] executionModes = {
1020 >            ExecutionMode.ASYNC,
1021 >            ExecutionMode.EXECUTOR,
1022 >        };
1023 >        for (ExecutionMode m : executionModes)
1024 >    {
1025 >        final FailingRunnable r = new FailingRunnable(m);
1026 >        final CompletableFuture<Void> f = m.runAsync(r);
1027          checkCompletedWithWrappedCFException(f);
1028 <        assertTrue(r.ran);
1029 <    }
1028 >        r.assertInvoked();
1029 >    }}
1030  
1031      /**
1032       * supplyAsync completes with result of supplier
1033       */
1034 <    public void testSupplyAsync() {
1035 <        CompletableFuture<Integer> f;
1036 <        f = CompletableFuture.supplyAsync(supplyOne);
1037 <        assertEquals(f.join(), one);
1038 <        checkCompletedNormally(f, one);
1039 <    }
1040 <
1041 <    /**
1042 <     * supplyAsync with executor completes with result of supplier
1043 <     */
1044 <    public void testSupplyAsync2() {
1045 <        CompletableFuture<Integer> f;
1046 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
1047 <        assertEquals(f.join(), one);
633 <        checkCompletedNormally(f, one);
634 <    }
1034 >    public void testSupplyAsync_normalCompletion() {
1035 >        ExecutionMode[] executionModes = {
1036 >            ExecutionMode.ASYNC,
1037 >            ExecutionMode.EXECUTOR,
1038 >        };
1039 >        for (ExecutionMode m : executionModes)
1040 >        for (Integer v1 : new Integer[] { 1, null })
1041 >    {
1042 >        final IntegerSupplier r = new IntegerSupplier(m, v1);
1043 >        final CompletableFuture<Integer> f = m.supplyAsync(r);
1044 >        assertSame(v1, f.join());
1045 >        checkCompletedNormally(f, v1);
1046 >        r.assertInvoked();
1047 >    }}
1048  
1049      /**
1050       * Failing supplyAsync completes exceptionally
1051       */
1052 <    public void testSupplyAsync3() {
1053 <        FailingSupplier r = new FailingSupplier();
1054 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1052 >    public void testSupplyAsync_exceptionalCompletion() {
1053 >        ExecutionMode[] executionModes = {
1054 >            ExecutionMode.ASYNC,
1055 >            ExecutionMode.EXECUTOR,
1056 >        };
1057 >        for (ExecutionMode m : executionModes)
1058 >    {
1059 >        FailingSupplier r = new FailingSupplier(m);
1060 >        CompletableFuture<Integer> f = m.supplyAsync(r);
1061          checkCompletedWithWrappedCFException(f);
1062 <        assertTrue(r.ran);
1063 <    }
1062 >        r.assertInvoked();
1063 >    }}
1064  
1065      // seq completion methods
1066  
1067      /**
1068       * thenRun result completes normally after normal completion of source
1069       */
1070 <    public void testThenRun() {
1071 <        CompletableFuture<Integer> f;
1072 <        CompletableFuture<Void> g;
1073 <        Noop r;
1074 <
1075 <        f = new CompletableFuture<>();
1076 <        g = f.thenRun(r = new Noop());
1077 <        f.complete(null);
1078 <        checkCompletedNormally(g, null);
1079 <        assertTrue(r.ran);
1070 >    public void testThenRun_normalCompletion() {
1071 >        for (ExecutionMode m : ExecutionMode.values())
1072 >        for (boolean createIncomplete : new boolean[] { true, false })
1073 >        for (Integer v1 : new Integer[] { 1, null })
1074 >    {
1075 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1076 >        final Noop r = new Noop(m);
1077 >        if (!createIncomplete) f.complete(v1);
1078 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1079 >        if (createIncomplete) {
1080 >            checkIncomplete(g);
1081 >            f.complete(v1);
1082 >        }
1083  
662        f = new CompletableFuture<>();
663        f.complete(null);
664        g = f.thenRun(r = new Noop());
1084          checkCompletedNormally(g, null);
1085 <        assertTrue(r.ran);
1086 <    }
1085 >        checkCompletedNormally(f, v1);
1086 >        r.assertInvoked();
1087 >    }}
1088  
1089      /**
1090       * thenRun result completes exceptionally after exceptional
1091       * completion of source
1092       */
1093 <    public void testThenRun2() {
1094 <        CompletableFuture<Integer> f;
1095 <        CompletableFuture<Void> g;
1096 <        Noop r;
1097 <
1098 <        f = new CompletableFuture<>();
1099 <        g = f.thenRun(r = new Noop());
1100 <        f.completeExceptionally(new CFException());
1101 <        checkCompletedWithWrappedCFException(g);
1102 <        assertFalse(r.ran);
1093 >    public void testThenRun_exceptionalCompletion() {
1094 >        for (ExecutionMode m : ExecutionMode.values())
1095 >        for (boolean createIncomplete : new boolean[] { true, false })
1096 >    {
1097 >        final CFException ex = new CFException();
1098 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1099 >        final Noop r = new Noop(m);
1100 >        if (!createIncomplete) f.completeExceptionally(ex);
1101 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1102 >        if (createIncomplete) {
1103 >            checkIncomplete(g);
1104 >            f.completeExceptionally(ex);
1105 >        }
1106  
1107 <        f = new CompletableFuture<>();
1108 <        f.completeExceptionally(new CFException());
1109 <        g = f.thenRun(r = new Noop());
1110 <        checkCompletedWithWrappedCFException(g);
688 <        assertFalse(r.ran);
689 <    }
1107 >        checkCompletedWithWrappedCFException(g, ex);
1108 >        checkCompletedWithWrappedCFException(f, ex);
1109 >        r.assertNotInvoked();
1110 >    }}
1111  
1112      /**
1113 <     * thenRun result completes exceptionally if action does
1113 >     * thenRun result completes exceptionally if source cancelled
1114       */
1115 <    public void testThenRun3() {
1116 <        CompletableFuture<Integer> f;
1117 <        CompletableFuture<Void> g;
1118 <        FailingNoop r;
1119 <
1120 <        f = new CompletableFuture<>();
1121 <        g = f.thenRun(r = new FailingNoop());
1122 <        f.complete(null);
1123 <        checkCompletedWithWrappedCFException(g);
1115 >    public void testThenRun_sourceCancelled() {
1116 >        for (ExecutionMode m : ExecutionMode.values())
1117 >        for (boolean createIncomplete : new boolean[] { true, false })
1118 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1119 >    {
1120 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1121 >        final Noop r = new Noop(m);
1122 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1123 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1124 >        if (createIncomplete) {
1125 >            checkIncomplete(g);
1126 >            assertTrue(f.cancel(mayInterruptIfRunning));
1127 >        }
1128  
1129 <        f = new CompletableFuture<>();
1130 <        f.complete(null);
1131 <        g = f.thenRun(r = new FailingNoop());
1132 <        checkCompletedWithWrappedCFException(g);
708 <    }
1129 >        checkCompletedWithWrappedCancellationException(g);
1130 >        checkCancelled(f);
1131 >        r.assertNotInvoked();
1132 >    }}
1133  
1134      /**
1135 <     * thenRun result completes exceptionally if source cancelled
1135 >     * thenRun result completes exceptionally if action does
1136       */
1137 <    public void testThenRun4() {
1138 <        CompletableFuture<Integer> f;
1139 <        CompletableFuture<Void> g;
1140 <        Noop r;
1141 <
1142 <        f = new CompletableFuture<>();
1143 <        g = f.thenRun(r = new Noop());
1144 <        assertTrue(f.cancel(true));
1145 <        checkCompletedWithWrappedCancellationException(g);
1137 >    public void testThenRun_actionFailed() {
1138 >        for (ExecutionMode m : ExecutionMode.values())
1139 >        for (boolean createIncomplete : new boolean[] { true, false })
1140 >        for (Integer v1 : new Integer[] { 1, null })
1141 >    {
1142 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1143 >        final FailingRunnable r = new FailingRunnable(m);
1144 >        if (!createIncomplete) f.complete(v1);
1145 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1146 >        if (createIncomplete) {
1147 >            checkIncomplete(g);
1148 >            f.complete(v1);
1149 >        }
1150  
1151 <        f = new CompletableFuture<>();
1152 <        assertTrue(f.cancel(true));
1153 <        g = f.thenRun(r = new Noop());
726 <        checkCompletedWithWrappedCancellationException(g);
727 <    }
1151 >        checkCompletedWithWrappedCFException(g);
1152 >        checkCompletedNormally(f, v1);
1153 >    }}
1154  
1155      /**
1156       * thenApply result completes normally after normal completion of source
1157       */
1158 <    public void testThenApply() {
1159 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1160 <        CompletableFuture<Integer> g = f.thenApply(inc);
1161 <        f.complete(one);
1162 <        checkCompletedNormally(g, two);
1163 <    }
1158 >    public void testThenApply_normalCompletion() {
1159 >        for (ExecutionMode m : ExecutionMode.values())
1160 >        for (boolean createIncomplete : new boolean[] { true, false })
1161 >        for (Integer v1 : new Integer[] { 1, null })
1162 >    {
1163 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1164 >        final IncFunction r = new IncFunction(m);
1165 >        if (!createIncomplete) f.complete(v1);
1166 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1167 >        if (createIncomplete) {
1168 >            checkIncomplete(g);
1169 >            f.complete(v1);
1170 >        }
1171 >
1172 >        checkCompletedNormally(g, inc(v1));
1173 >        checkCompletedNormally(f, v1);
1174 >        r.assertInvoked();
1175 >    }}
1176  
1177      /**
1178       * thenApply result completes exceptionally after exceptional
1179       * completion of source
1180       */
1181 <    public void testThenApply2() {
1182 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1183 <        CompletableFuture<Integer> g = f.thenApply(inc);
1184 <        f.completeExceptionally(new CFException());
1185 <        checkCompletedWithWrappedCFException(g);
1186 <    }
1181 >    public void testThenApply_exceptionalCompletion() {
1182 >        for (ExecutionMode m : ExecutionMode.values())
1183 >        for (boolean createIncomplete : new boolean[] { true, false })
1184 >    {
1185 >        final CFException ex = new CFException();
1186 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1187 >        final IncFunction r = new IncFunction(m);
1188 >        if (!createIncomplete) f.completeExceptionally(ex);
1189 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1190 >        if (createIncomplete) {
1191 >            checkIncomplete(g);
1192 >            f.completeExceptionally(ex);
1193 >        }
1194  
1195 <    /**
1196 <     * thenApply result completes exceptionally if action does
1197 <     */
1198 <    public void testThenApply3() {
754 <        CompletableFuture<Integer> f = new CompletableFuture<>();
755 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
756 <        f.complete(one);
757 <        checkCompletedWithWrappedCFException(g);
758 <    }
1195 >        checkCompletedWithWrappedCFException(g, ex);
1196 >        checkCompletedWithWrappedCFException(f, ex);
1197 >        r.assertNotInvoked();
1198 >    }}
1199  
1200      /**
1201       * thenApply result completes exceptionally if source cancelled
1202       */
1203 <    public void testThenApply4() {
1204 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1205 <        CompletableFuture<Integer> g = f.thenApply(inc);
1206 <        assertTrue(f.cancel(true));
1203 >    public void testThenApply_sourceCancelled() {
1204 >        for (ExecutionMode m : ExecutionMode.values())
1205 >        for (boolean createIncomplete : new boolean[] { true, false })
1206 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1207 >    {
1208 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1209 >        final IncFunction r = new IncFunction(m);
1210 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1211 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1212 >        if (createIncomplete) {
1213 >            checkIncomplete(g);
1214 >            assertTrue(f.cancel(mayInterruptIfRunning));
1215 >        }
1216 >
1217          checkCompletedWithWrappedCancellationException(g);
1218 <    }
1218 >        checkCancelled(f);
1219 >        r.assertNotInvoked();
1220 >    }}
1221 >
1222 >    /**
1223 >     * thenApply result completes exceptionally if action does
1224 >     */
1225 >    public void testThenApply_actionFailed() {
1226 >        for (ExecutionMode m : ExecutionMode.values())
1227 >        for (boolean createIncomplete : new boolean[] { true, false })
1228 >        for (Integer v1 : new Integer[] { 1, null })
1229 >    {
1230 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1231 >        final FailingFunction r = new FailingFunction(m);
1232 >        if (!createIncomplete) f.complete(v1);
1233 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1234 >        if (createIncomplete) {
1235 >            checkIncomplete(g);
1236 >            f.complete(v1);
1237 >        }
1238 >
1239 >        checkCompletedWithWrappedCFException(g);
1240 >        checkCompletedNormally(f, v1);
1241 >    }}
1242  
1243      /**
1244       * thenAccept result completes normally after normal completion of source
1245       */
1246 <    public void testThenAccept() {
1247 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1248 <        IncAction r = new IncAction();
1249 <        CompletableFuture<Void> g = f.thenAccept(r);
1250 <        f.complete(one);
1246 >    public void testThenAccept_normalCompletion() {
1247 >        for (ExecutionMode m : ExecutionMode.values())
1248 >        for (boolean createIncomplete : new boolean[] { true, false })
1249 >        for (Integer v1 : new Integer[] { 1, null })
1250 >    {
1251 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1252 >        final NoopConsumer r = new NoopConsumer(m);
1253 >        if (!createIncomplete) f.complete(v1);
1254 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1255 >        if (createIncomplete) {
1256 >            checkIncomplete(g);
1257 >            f.complete(v1);
1258 >        }
1259 >
1260          checkCompletedNormally(g, null);
1261 <        assertEquals(r.value, 2);
1262 <    }
1261 >        r.assertValue(v1);
1262 >        checkCompletedNormally(f, v1);
1263 >    }}
1264  
1265      /**
1266       * thenAccept result completes exceptionally after exceptional
1267       * completion of source
1268       */
1269 <    public void testThenAccept2() {
1270 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1271 <        IncAction r = new IncAction();
1272 <        CompletableFuture<Void> g = f.thenAccept(r);
1273 <        f.completeExceptionally(new CFException());
1274 <        checkCompletedWithWrappedCFException(g);
1275 <    }
1269 >    public void testThenAccept_exceptionalCompletion() {
1270 >        for (ExecutionMode m : ExecutionMode.values())
1271 >        for (boolean createIncomplete : new boolean[] { true, false })
1272 >    {
1273 >        final CFException ex = new CFException();
1274 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1275 >        final NoopConsumer r = new NoopConsumer(m);
1276 >        if (!createIncomplete) f.completeExceptionally(ex);
1277 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1278 >        if (createIncomplete) {
1279 >            checkIncomplete(g);
1280 >            f.completeExceptionally(ex);
1281 >        }
1282  
1283 <    /**
1284 <     * thenAccept result completes exceptionally if action does
1285 <     */
1286 <    public void testThenAccept3() {
798 <        CompletableFuture<Integer> f = new CompletableFuture<>();
799 <        FailingConsumer r = new FailingConsumer();
800 <        CompletableFuture<Void> g = f.thenAccept(r);
801 <        f.complete(one);
802 <        checkCompletedWithWrappedCFException(g);
803 <        assertTrue(r.ran);
804 <    }
1283 >        checkCompletedWithWrappedCFException(g, ex);
1284 >        checkCompletedWithWrappedCFException(f, ex);
1285 >        r.assertNotInvoked();
1286 >    }}
1287  
1288      /**
1289       * thenAccept result completes exceptionally if source cancelled
1290       */
1291 <    public void testThenAccept4() {
1292 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1293 <        IncAction r = new IncAction();
1294 <        CompletableFuture<Void> g = f.thenAccept(r);
1295 <        assertTrue(f.cancel(true));
1291 >    public void testThenAccept_sourceCancelled() {
1292 >        for (ExecutionMode m : ExecutionMode.values())
1293 >        for (boolean createIncomplete : new boolean[] { true, false })
1294 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1295 >    {
1296 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1297 >        final NoopConsumer r = new NoopConsumer(m);
1298 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1299 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1300 >        if (createIncomplete) {
1301 >            checkIncomplete(g);
1302 >            assertTrue(f.cancel(mayInterruptIfRunning));
1303 >        }
1304 >
1305          checkCompletedWithWrappedCancellationException(g);
1306 <    }
1306 >        checkCancelled(f);
1307 >        r.assertNotInvoked();
1308 >    }}
1309  
1310      /**
1311 <     * thenCombine result completes normally after normal completion
819 <     * of sources
1311 >     * thenAccept result completes exceptionally if action does
1312       */
1313 <    public void testThenCombine_normalCompletion1() {
1313 >    public void testThenAccept_actionFailed() {
1314          for (ExecutionMode m : ExecutionMode.values())
1315 +        for (boolean createIncomplete : new boolean[] { true, false })
1316          for (Integer v1 : new Integer[] { 1, null })
1317 <        for (Integer v2 : new Integer[] { 2, null }) {
825 <
1317 >    {
1318          final CompletableFuture<Integer> f = new CompletableFuture<>();
1319 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1320 <        final SubtractFunction r = new SubtractFunction();
1321 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1322 <
1323 <        f.complete(v1);
1324 <        checkIncomplete(h);
833 <        assertFalse(r.ran());
834 <        g.complete(v2);
835 <
836 <        checkCompletedNormally(h, subtract(v1, v2));
837 <        checkCompletedNormally(f, v1);
838 <        checkCompletedNormally(g, v2);
1319 >        final FailingConsumer r = new FailingConsumer(m);
1320 >        if (!createIncomplete) f.complete(v1);
1321 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1322 >        if (createIncomplete) {
1323 >            checkIncomplete(g);
1324 >            f.complete(v1);
1325          }
840    }
841
842    public void testThenCombine_normalCompletion2() {
843        for (ExecutionMode m : ExecutionMode.values())
844        for (Integer v1 : new Integer[] { 1, null })
845        for (Integer v2 : new Integer[] { 2, null }) {
1326  
1327 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
848 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
849 <        final SubtractFunction r = new SubtractFunction();
850 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
851 <
852 <        g.complete(v2);
853 <        checkIncomplete(h);
854 <        assertFalse(r.ran());
855 <        f.complete(v1);
856 <
857 <        checkCompletedNormally(h, subtract(v1, v2));
1327 >        checkCompletedWithWrappedCFException(g);
1328          checkCompletedNormally(f, v1);
1329 <        checkCompletedNormally(g, v2);
860 <        }
861 <    }
1329 >    }}
1330  
1331 <    public void testThenCombine_normalCompletion3() {
1331 >    /**
1332 >     * thenCombine result completes normally after normal completion
1333 >     * of sources
1334 >     */
1335 >    public void testThenCombine_normalCompletion() {
1336          for (ExecutionMode m : ExecutionMode.values())
1337 +        for (boolean createIncomplete : new boolean[] { true, false })
1338 +        for (boolean fFirst : new boolean[] { true, false })
1339          for (Integer v1 : new Integer[] { 1, null })
1340 <        for (Integer v2 : new Integer[] { 2, null }) {
1341 <
1340 >        for (Integer v2 : new Integer[] { 2, null })
1341 >    {
1342          final CompletableFuture<Integer> f = new CompletableFuture<>();
1343          final CompletableFuture<Integer> g = new CompletableFuture<>();
1344 <        final SubtractFunction r = new SubtractFunction();
1344 >        final SubtractFunction r = new SubtractFunction(m);
1345  
1346 <        g.complete(v2);
1347 <        f.complete(v1);
1346 >        if (fFirst) f.complete(v1); else g.complete(v2);
1347 >        if (!createIncomplete)
1348 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1349          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1350 <
1351 <        checkCompletedNormally(h, subtract(v1, v2));
1352 <        checkCompletedNormally(f, v1);
1353 <        checkCompletedNormally(g, v2);
1350 >        if (createIncomplete) {
1351 >            checkIncomplete(h);
1352 >            r.assertNotInvoked();
1353 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1354          }
880    }
881
882    public void testThenCombine_normalCompletion4() {
883        for (ExecutionMode m : ExecutionMode.values())
884        for (Integer v1 : new Integer[] { 1, null })
885        for (Integer v2 : new Integer[] { 2, null }) {
886
887        final CompletableFuture<Integer> f = new CompletableFuture<>();
888        final CompletableFuture<Integer> g = new CompletableFuture<>();
889        final SubtractFunction r = new SubtractFunction();
890
891        f.complete(v1);
892        g.complete(v2);
893        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1355  
1356          checkCompletedNormally(h, subtract(v1, v2));
1357          checkCompletedNormally(f, v1);
1358          checkCompletedNormally(g, v2);
1359 <        }
1360 <    }
1359 >        r.assertInvoked();
1360 >    }}
1361  
1362      /**
1363       * thenCombine result completes exceptionally after exceptional
1364       * completion of either source
1365       */
1366 <    public void testThenCombine_exceptionalCompletion1() {
1366 >    public void testThenCombine_exceptionalCompletion() {
1367          for (ExecutionMode m : ExecutionMode.values())
1368 <        for (Integer v1 : new Integer[] { 1, null }) {
1369 <
1368 >        for (boolean createIncomplete : new boolean[] { true, false })
1369 >        for (boolean fFirst : new boolean[] { true, false })
1370 >        for (Integer v1 : new Integer[] { 1, null })
1371 >    {
1372          final CompletableFuture<Integer> f = new CompletableFuture<>();
1373          final CompletableFuture<Integer> g = new CompletableFuture<>();
911        final SubtractFunction r = new SubtractFunction();
912        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1374          final CFException ex = new CFException();
1375 +        final SubtractFunction r = new SubtractFunction(m);
1376  
1377 <        f.completeExceptionally(ex);
1378 <        checkIncomplete(h);
1379 <        g.complete(v1);
1380 <
1381 <        checkCompletedWithWrappedCFException(h, ex);
1382 <        checkCompletedWithWrappedCFException(f, ex);
1383 <        assertFalse(r.ran());
922 <        checkCompletedNormally(g, v1);
1377 >        (fFirst ? f : g).complete(v1);
1378 >        if (!createIncomplete)
1379 >            (!fFirst ? f : g).completeExceptionally(ex);
1380 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1381 >        if (createIncomplete) {
1382 >            checkIncomplete(h);
1383 >            (!fFirst ? f : g).completeExceptionally(ex);
1384          }
924    }
925
926    public void testThenCombine_exceptionalCompletion2() {
927        for (ExecutionMode m : ExecutionMode.values())
928        for (Integer v1 : new Integer[] { 1, null }) {
929
930        final CompletableFuture<Integer> f = new CompletableFuture<>();
931        final CompletableFuture<Integer> g = new CompletableFuture<>();
932        final SubtractFunction r = new SubtractFunction();
933        final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
934        final CFException ex = new CFException();
935
936        g.completeExceptionally(ex);
937        checkIncomplete(h);
938        f.complete(v1);
1385  
1386          checkCompletedWithWrappedCFException(h, ex);
1387 <        checkCompletedWithWrappedCFException(g, ex);
1388 <        assertFalse(r.ran());
1389 <        checkCompletedNormally(f, v1);
1390 <        }
945 <    }
1387 >        r.assertNotInvoked();
1388 >        checkCompletedNormally(fFirst ? f : g, v1);
1389 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1390 >    }}
1391  
1392 <    public void testThenCombine_exceptionalCompletion3() {
1392 >    /**
1393 >     * thenCombine result completes exceptionally if either source cancelled
1394 >     */
1395 >    public void testThenCombine_sourceCancelled() {
1396          for (ExecutionMode m : ExecutionMode.values())
1397 <        for (Integer v1 : new Integer[] { 1, null }) {
1398 <
1397 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1398 >        for (boolean createIncomplete : new boolean[] { true, false })
1399 >        for (boolean fFirst : new boolean[] { true, false })
1400 >        for (Integer v1 : new Integer[] { 1, null })
1401 >    {
1402          final CompletableFuture<Integer> f = new CompletableFuture<>();
1403          final CompletableFuture<Integer> g = new CompletableFuture<>();
1404 <        final SubtractFunction r = new SubtractFunction();
954 <        final CFException ex = new CFException();
1404 >        final SubtractFunction r = new SubtractFunction(m);
1405  
1406 <        g.completeExceptionally(ex);
1407 <        f.complete(v1);
1406 >        (fFirst ? f : g).complete(v1);
1407 >        if (!createIncomplete)
1408 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1409          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1410 <
1411 <        checkCompletedWithWrappedCFException(h, ex);
1412 <        checkCompletedWithWrappedCFException(g, ex);
962 <        assertFalse(r.ran());
963 <        checkCompletedNormally(f, v1);
1410 >        if (createIncomplete) {
1411 >            checkIncomplete(h);
1412 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1413          }
965    }
1414  
1415 <    public void testThenCombine_exceptionalCompletion4() {
1416 <        for (ExecutionMode m : ExecutionMode.values())
1417 <        for (Integer v1 : new Integer[] { 1, null }) {
1418 <
1419 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
972 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
973 <        final SubtractFunction r = new SubtractFunction();
974 <        final CFException ex = new CFException();
975 <
976 <        f.completeExceptionally(ex);
977 <        g.complete(v1);
978 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
979 <
980 <        checkCompletedWithWrappedCFException(h, ex);
981 <        checkCompletedWithWrappedCFException(f, ex);
982 <        assertFalse(r.ran());
983 <        checkCompletedNormally(g, v1);
984 <        }
985 <    }
1415 >        checkCompletedWithWrappedCancellationException(h);
1416 >        checkCancelled(!fFirst ? f : g);
1417 >        r.assertNotInvoked();
1418 >        checkCompletedNormally(fFirst ? f : g, v1);
1419 >    }}
1420  
1421      /**
1422       * thenCombine result completes exceptionally if action does
1423       */
1424 <    public void testThenCombine_actionFailed1() {
1424 >    public void testThenCombine_actionFailed() {
1425          for (ExecutionMode m : ExecutionMode.values())
1426 +        for (boolean fFirst : new boolean[] { true, false })
1427          for (Integer v1 : new Integer[] { 1, null })
1428 <        for (Integer v2 : new Integer[] { 2, null }) {
1429 <
1428 >        for (Integer v2 : new Integer[] { 2, null })
1429 >    {
1430          final CompletableFuture<Integer> f = new CompletableFuture<>();
1431          final CompletableFuture<Integer> g = new CompletableFuture<>();
1432 <        final FailingBiFunction r = new FailingBiFunction();
1432 >        final FailingBiFunction r = new FailingBiFunction(m);
1433          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1434  
1435 <        f.complete(v1);
1436 <        checkIncomplete(h);
1437 <        g.complete(v2);
1435 >        if (fFirst) {
1436 >            f.complete(v1);
1437 >            g.complete(v2);
1438 >        } else {
1439 >            g.complete(v2);
1440 >            f.complete(v1);
1441 >        }
1442  
1443          checkCompletedWithWrappedCFException(h);
1444          checkCompletedNormally(f, v1);
1445          checkCompletedNormally(g, v2);
1446 <        }
1008 <    }
1446 >    }}
1447  
1448 <    public void testThenCombine_actionFailed2() {
1448 >    /**
1449 >     * thenAcceptBoth result completes normally after normal
1450 >     * completion of sources
1451 >     */
1452 >    public void testThenAcceptBoth_normalCompletion() {
1453          for (ExecutionMode m : ExecutionMode.values())
1454 +        for (boolean createIncomplete : new boolean[] { true, false })
1455 +        for (boolean fFirst : new boolean[] { true, false })
1456          for (Integer v1 : new Integer[] { 1, null })
1457 <        for (Integer v2 : new Integer[] { 2, null }) {
1458 <
1457 >        for (Integer v2 : new Integer[] { 2, null })
1458 >    {
1459          final CompletableFuture<Integer> f = new CompletableFuture<>();
1460          final CompletableFuture<Integer> g = new CompletableFuture<>();
1461 <        final FailingBiFunction r = new FailingBiFunction();
1018 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1461 >        final SubtractAction r = new SubtractAction(m);
1462  
1463 <        g.complete(v2);
1464 <        checkIncomplete(h);
1465 <        f.complete(v1);
1463 >        if (fFirst) f.complete(v1); else g.complete(v2);
1464 >        if (!createIncomplete)
1465 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1466 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1467 >        if (createIncomplete) {
1468 >            checkIncomplete(h);
1469 >            r.assertNotInvoked();
1470 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1471 >        }
1472  
1473 <        checkCompletedWithWrappedCFException(h);
1473 >        checkCompletedNormally(h, null);
1474 >        r.assertValue(subtract(v1, v2));
1475          checkCompletedNormally(f, v1);
1476          checkCompletedNormally(g, v2);
1477 <        }
1028 <    }
1477 >    }}
1478  
1479      /**
1480 <     * thenCombine result completes exceptionally if either source cancelled
1480 >     * thenAcceptBoth result completes exceptionally after exceptional
1481 >     * completion of either source
1482       */
1483 <    public void testThenCombine_sourceCancelled1() {
1483 >    public void testThenAcceptBoth_exceptionalCompletion() {
1484          for (ExecutionMode m : ExecutionMode.values())
1485 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1486 <        for (Integer v1 : new Integer[] { 1, null }) {
1487 <
1485 >        for (boolean createIncomplete : new boolean[] { true, false })
1486 >        for (boolean fFirst : new boolean[] { true, false })
1487 >        for (Integer v1 : new Integer[] { 1, null })
1488 >    {
1489          final CompletableFuture<Integer> f = new CompletableFuture<>();
1490          final CompletableFuture<Integer> g = new CompletableFuture<>();
1491 <        final SubtractFunction r = new SubtractFunction();
1492 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1042 <
1043 <        assertTrue(f.cancel(mayInterruptIfRunning));
1044 <        checkIncomplete(h);
1045 <        g.complete(v1);
1491 >        final CFException ex = new CFException();
1492 >        final SubtractAction r = new SubtractAction(m);
1493  
1494 <        checkCompletedWithWrappedCancellationException(h);
1495 <        checkCancelled(f);
1496 <        assertFalse(r.ran());
1497 <        checkCompletedNormally(g, v1);
1494 >        (fFirst ? f : g).complete(v1);
1495 >        if (!createIncomplete)
1496 >            (!fFirst ? f : g).completeExceptionally(ex);
1497 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1498 >        if (createIncomplete) {
1499 >            checkIncomplete(h);
1500 >            (!fFirst ? f : g).completeExceptionally(ex);
1501          }
1052    }
1502  
1503 <    public void testThenCombine_sourceCancelled2() {
1504 <        for (ExecutionMode m : ExecutionMode.values())
1505 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1506 <        for (Integer v1 : new Integer[] { 1, null }) {
1507 <
1059 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1060 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1061 <        final SubtractFunction r = new SubtractFunction();
1062 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1063 <
1064 <        assertTrue(g.cancel(mayInterruptIfRunning));
1065 <        checkIncomplete(h);
1066 <        f.complete(v1);
1067 <
1068 <        checkCompletedWithWrappedCancellationException(h);
1069 <        checkCancelled(g);
1070 <        assertFalse(r.ran());
1071 <        checkCompletedNormally(f, v1);
1072 <        }
1073 <    }
1503 >        checkCompletedWithWrappedCFException(h, ex);
1504 >        r.assertNotInvoked();
1505 >        checkCompletedNormally(fFirst ? f : g, v1);
1506 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1507 >    }}
1508  
1509 <    public void testThenCombine_sourceCancelled3() {
1509 >    /**
1510 >     * thenAcceptBoth result completes exceptionally if either source cancelled
1511 >     */
1512 >    public void testThenAcceptBoth_sourceCancelled() {
1513          for (ExecutionMode m : ExecutionMode.values())
1514          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1515 <        for (Integer v1 : new Integer[] { 1, null }) {
1516 <
1515 >        for (boolean createIncomplete : new boolean[] { true, false })
1516 >        for (boolean fFirst : new boolean[] { true, false })
1517 >        for (Integer v1 : new Integer[] { 1, null })
1518 >    {
1519          final CompletableFuture<Integer> f = new CompletableFuture<>();
1520          final CompletableFuture<Integer> g = new CompletableFuture<>();
1521 <        final SubtractFunction r = new SubtractFunction();
1083 <
1084 <        assertTrue(g.cancel(mayInterruptIfRunning));
1085 <        f.complete(v1);
1086 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1521 >        final SubtractAction r = new SubtractAction(m);
1522  
1523 <        checkCompletedWithWrappedCancellationException(h);
1524 <        checkCancelled(g);
1525 <        assertFalse(r.ran());
1526 <        checkCompletedNormally(f, v1);
1523 >        (fFirst ? f : g).complete(v1);
1524 >        if (!createIncomplete)
1525 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1526 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1527 >        if (createIncomplete) {
1528 >            checkIncomplete(h);
1529 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1530          }
1093    }
1094
1095    public void testThenCombine_sourceCancelled4() {
1096        for (ExecutionMode m : ExecutionMode.values())
1097        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1098        for (Integer v1 : new Integer[] { 1, null }) {
1099
1100        final CompletableFuture<Integer> f = new CompletableFuture<>();
1101        final CompletableFuture<Integer> g = new CompletableFuture<>();
1102        final SubtractFunction r = new SubtractFunction();
1103
1104        assertTrue(f.cancel(mayInterruptIfRunning));
1105        g.complete(v1);
1106        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1531  
1532          checkCompletedWithWrappedCancellationException(h);
1533 <        checkCancelled(f);
1534 <        assertFalse(r.ran());
1535 <        checkCompletedNormally(g, v1);
1536 <        }
1113 <    }
1533 >        checkCancelled(!fFirst ? f : g);
1534 >        r.assertNotInvoked();
1535 >        checkCompletedNormally(fFirst ? f : g, v1);
1536 >    }}
1537  
1538      /**
1539 <     * thenAcceptBoth result completes normally after normal
1117 <     * completion of sources
1539 >     * thenAcceptBoth result completes exceptionally if action does
1540       */
1541 <    public void testThenAcceptBoth_normalCompletion1() {
1541 >    public void testThenAcceptBoth_actionFailed() {
1542          for (ExecutionMode m : ExecutionMode.values())
1543 +        for (boolean fFirst : new boolean[] { true, false })
1544          for (Integer v1 : new Integer[] { 1, null })
1545 <        for (Integer v2 : new Integer[] { 2, null }) {
1546 <
1545 >        for (Integer v2 : new Integer[] { 2, null })
1546 >    {
1547          final CompletableFuture<Integer> f = new CompletableFuture<>();
1548          final CompletableFuture<Integer> g = new CompletableFuture<>();
1549 <        final SubtractAction r = new SubtractAction();
1549 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1550          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1551  
1552 <        f.complete(v1);
1553 <        checkIncomplete(h);
1554 <        assertEquals(r.value, 0);
1555 <        g.complete(v2);
1556 <
1557 <        checkCompletedNormally(h, null);
1135 <        assertEquals(r.value, subtract(v1, v2));
1136 <        checkCompletedNormally(f, v1);
1137 <        checkCompletedNormally(g, v2);
1552 >        if (fFirst) {
1553 >            f.complete(v1);
1554 >            g.complete(v2);
1555 >        } else {
1556 >            g.complete(v2);
1557 >            f.complete(v1);
1558          }
1139    }
1140
1141    public void testThenAcceptBoth_normalCompletion2() {
1142        for (ExecutionMode m : ExecutionMode.values())
1143        for (Integer v1 : new Integer[] { 1, null })
1144        for (Integer v2 : new Integer[] { 2, null }) {
1145
1146        final CompletableFuture<Integer> f = new CompletableFuture<>();
1147        final CompletableFuture<Integer> g = new CompletableFuture<>();
1148        final SubtractAction r = new SubtractAction();
1149        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1150
1151        g.complete(v2);
1152        checkIncomplete(h);
1153        assertEquals(r.value, 0);
1154        f.complete(v1);
1559  
1560 <        checkCompletedNormally(h, null);
1157 <        assertEquals(r.value, subtract(v1, v2));
1560 >        checkCompletedWithWrappedCFException(h);
1561          checkCompletedNormally(f, v1);
1562          checkCompletedNormally(g, v2);
1563 <        }
1161 <    }
1563 >    }}
1564  
1565 <    public void testThenAcceptBoth_normalCompletion3() {
1565 >    /**
1566 >     * runAfterBoth result completes normally after normal
1567 >     * completion of sources
1568 >     */
1569 >    public void testRunAfterBoth_normalCompletion() {
1570          for (ExecutionMode m : ExecutionMode.values())
1571 +        for (boolean createIncomplete : new boolean[] { true, false })
1572 +        for (boolean fFirst : new boolean[] { true, false })
1573          for (Integer v1 : new Integer[] { 1, null })
1574 <        for (Integer v2 : new Integer[] { 2, null }) {
1575 <
1574 >        for (Integer v2 : new Integer[] { 2, null })
1575 >    {
1576          final CompletableFuture<Integer> f = new CompletableFuture<>();
1577          final CompletableFuture<Integer> g = new CompletableFuture<>();
1578 <        final SubtractAction r = new SubtractAction();
1578 >        final Noop r = new Noop(m);
1579  
1580 <        g.complete(v2);
1581 <        f.complete(v1);
1582 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1583 <
1584 <        checkCompletedNormally(h, null);
1585 <        assertEquals(r.value, subtract(v1, v2));
1586 <        checkCompletedNormally(f, v1);
1587 <        checkCompletedNormally(g, v2);
1580 >        if (fFirst) f.complete(v1); else g.complete(v2);
1581 >        if (!createIncomplete)
1582 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1583 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1584 >        if (createIncomplete) {
1585 >            checkIncomplete(h);
1586 >            r.assertNotInvoked();
1587 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1588          }
1181    }
1182
1183    public void testThenAcceptBoth_normalCompletion4() {
1184        for (ExecutionMode m : ExecutionMode.values())
1185        for (Integer v1 : new Integer[] { 1, null })
1186        for (Integer v2 : new Integer[] { 2, null }) {
1187
1188        final CompletableFuture<Integer> f = new CompletableFuture<>();
1189        final CompletableFuture<Integer> g = new CompletableFuture<>();
1190        final SubtractAction r = new SubtractAction();
1191
1192        f.complete(v1);
1193        g.complete(v2);
1194        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1589  
1590          checkCompletedNormally(h, null);
1591 <        assertEquals(r.value, subtract(v1, v2));
1591 >        r.assertInvoked();
1592          checkCompletedNormally(f, v1);
1593          checkCompletedNormally(g, v2);
1594 <        }
1201 <    }
1594 >    }}
1595  
1596      /**
1597 <     * thenAcceptBoth result completes exceptionally after exceptional
1597 >     * runAfterBoth result completes exceptionally after exceptional
1598       * completion of either source
1599       */
1600 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1600 >    public void testRunAfterBoth_exceptionalCompletion() {
1601          for (ExecutionMode m : ExecutionMode.values())
1602 <        for (Integer v1 : new Integer[] { 1, null }) {
1603 <
1602 >        for (boolean createIncomplete : new boolean[] { true, false })
1603 >        for (boolean fFirst : new boolean[] { true, false })
1604 >        for (Integer v1 : new Integer[] { 1, null })
1605 >    {
1606          final CompletableFuture<Integer> f = new CompletableFuture<>();
1607          final CompletableFuture<Integer> g = new CompletableFuture<>();
1213        final SubtractAction r = new SubtractAction();
1214        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1608          final CFException ex = new CFException();
1609 +        final Noop r = new Noop(m);
1610  
1611 <        f.completeExceptionally(ex);
1612 <        checkIncomplete(h);
1613 <        g.complete(v1);
1614 <
1615 <        checkCompletedWithWrappedCFException(h, ex);
1616 <        checkCompletedWithWrappedCFException(f, ex);
1617 <        assertFalse(r.ran());
1224 <        checkCompletedNormally(g, v1);
1611 >        (fFirst ? f : g).complete(v1);
1612 >        if (!createIncomplete)
1613 >            (!fFirst ? f : g).completeExceptionally(ex);
1614 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1615 >        if (createIncomplete) {
1616 >            checkIncomplete(h);
1617 >            (!fFirst ? f : g).completeExceptionally(ex);
1618          }
1226    }
1227
1228    public void testThenAcceptBoth_exceptionalCompletion2() {
1229        for (ExecutionMode m : ExecutionMode.values())
1230        for (Integer v1 : new Integer[] { 1, null }) {
1231
1232        final CompletableFuture<Integer> f = new CompletableFuture<>();
1233        final CompletableFuture<Integer> g = new CompletableFuture<>();
1234        final SubtractAction r = new SubtractAction();
1235        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1236        final CFException ex = new CFException();
1237
1238        g.completeExceptionally(ex);
1239        checkIncomplete(h);
1240        f.complete(v1);
1619  
1620          checkCompletedWithWrappedCFException(h, ex);
1621 <        checkCompletedWithWrappedCFException(g, ex);
1622 <        assertFalse(r.ran());
1623 <        checkCompletedNormally(f, v1);
1624 <        }
1247 <    }
1621 >        r.assertNotInvoked();
1622 >        checkCompletedNormally(fFirst ? f : g, v1);
1623 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1624 >    }}
1625  
1626 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1626 >    /**
1627 >     * runAfterBoth result completes exceptionally if either source cancelled
1628 >     */
1629 >    public void testRunAfterBoth_sourceCancelled() {
1630          for (ExecutionMode m : ExecutionMode.values())
1631 <        for (Integer v1 : new Integer[] { 1, null }) {
1632 <
1631 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1632 >        for (boolean createIncomplete : new boolean[] { true, false })
1633 >        for (boolean fFirst : new boolean[] { true, false })
1634 >        for (Integer v1 : new Integer[] { 1, null })
1635 >    {
1636          final CompletableFuture<Integer> f = new CompletableFuture<>();
1637          final CompletableFuture<Integer> g = new CompletableFuture<>();
1638 <        final SubtractAction r = new SubtractAction();
1256 <        final CFException ex = new CFException();
1638 >        final Noop r = new Noop(m);
1639  
1258        g.completeExceptionally(ex);
1259        f.complete(v1);
1260        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1640  
1641 <        checkCompletedWithWrappedCFException(h, ex);
1642 <        checkCompletedWithWrappedCFException(g, ex);
1643 <        assertFalse(r.ran());
1644 <        checkCompletedNormally(f, v1);
1641 >        (fFirst ? f : g).complete(v1);
1642 >        if (!createIncomplete)
1643 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1644 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1645 >        if (createIncomplete) {
1646 >            checkIncomplete(h);
1647 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1648          }
1267    }
1268
1269    public void testThenAcceptBoth_exceptionalCompletion4() {
1270        for (ExecutionMode m : ExecutionMode.values())
1271        for (Integer v1 : new Integer[] { 1, null }) {
1272
1273        final CompletableFuture<Integer> f = new CompletableFuture<>();
1274        final CompletableFuture<Integer> g = new CompletableFuture<>();
1275        final SubtractAction r = new SubtractAction();
1276        final CFException ex = new CFException();
1277
1278        f.completeExceptionally(ex);
1279        g.complete(v1);
1280        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1649  
1650 <        checkCompletedWithWrappedCFException(h, ex);
1651 <        checkCompletedWithWrappedCFException(f, ex);
1652 <        assertFalse(r.ran());
1653 <        checkCompletedNormally(g, v1);
1654 <        }
1287 <    }
1650 >        checkCompletedWithWrappedCancellationException(h);
1651 >        checkCancelled(!fFirst ? f : g);
1652 >        r.assertNotInvoked();
1653 >        checkCompletedNormally(fFirst ? f : g, v1);
1654 >    }}
1655  
1656      /**
1657 <     * thenAcceptBoth result completes exceptionally if action does
1657 >     * runAfterBoth result completes exceptionally if action does
1658       */
1659 <    public void testThenAcceptBoth_actionFailed1() {
1659 >    public void testRunAfterBoth_actionFailed() {
1660          for (ExecutionMode m : ExecutionMode.values())
1661 +        for (boolean fFirst : new boolean[] { true, false })
1662          for (Integer v1 : new Integer[] { 1, null })
1663 <        for (Integer v2 : new Integer[] { 2, null }) {
1664 <
1663 >        for (Integer v2 : new Integer[] { 2, null })
1664 >    {
1665          final CompletableFuture<Integer> f = new CompletableFuture<>();
1666          final CompletableFuture<Integer> g = new CompletableFuture<>();
1667 <        final FailingBiConsumer r = new FailingBiConsumer();
1668 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1667 >        final FailingRunnable r1 = new FailingRunnable(m);
1668 >        final FailingRunnable r2 = new FailingRunnable(m);
1669  
1670 <        f.complete(v1);
1671 <        checkIncomplete(h);
1672 <        g.complete(v2);
1670 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1671 >        if (fFirst) {
1672 >            f.complete(v1);
1673 >            g.complete(v2);
1674 >        } else {
1675 >            g.complete(v2);
1676 >            f.complete(v1);
1677 >        }
1678 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1679  
1680 <        checkCompletedWithWrappedCFException(h);
1680 >        checkCompletedWithWrappedCFException(h1);
1681 >        checkCompletedWithWrappedCFException(h2);
1682          checkCompletedNormally(f, v1);
1683          checkCompletedNormally(g, v2);
1684 <        }
1310 <    }
1684 >    }}
1685  
1686 <    public void testThenAcceptBoth_actionFailed2() {
1686 >    /**
1687 >     * applyToEither result completes normally after normal completion
1688 >     * of either source
1689 >     */
1690 >    public void testApplyToEither_normalCompletion() {
1691          for (ExecutionMode m : ExecutionMode.values())
1692          for (Integer v1 : new Integer[] { 1, null })
1693 <        for (Integer v2 : new Integer[] { 2, null }) {
1694 <
1693 >        for (Integer v2 : new Integer[] { 2, null })
1694 >    {
1695          final CompletableFuture<Integer> f = new CompletableFuture<>();
1696          final CompletableFuture<Integer> g = new CompletableFuture<>();
1697 <        final FailingBiConsumer r = new FailingBiConsumer();
1698 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1697 >        final IncFunction[] rs = new IncFunction[6];
1698 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1699  
1700 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1701 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1702 +        checkIncomplete(h0);
1703 +        checkIncomplete(h1);
1704 +        rs[0].assertNotInvoked();
1705 +        rs[1].assertNotInvoked();
1706 +        f.complete(v1);
1707 +        checkCompletedNormally(h0, inc(v1));
1708 +        checkCompletedNormally(h1, inc(v1));
1709 +        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1710 +        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1711 +        checkCompletedNormally(h2, inc(v1));
1712 +        checkCompletedNormally(h3, inc(v1));
1713          g.complete(v2);
1323        checkIncomplete(h);
1324        f.complete(v1);
1714  
1715 <        checkCompletedWithWrappedCFException(h);
1715 >        // unspecified behavior - both source completions available
1716 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1717 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1718 >        rs[4].assertValue(h4.join());
1719 >        rs[5].assertValue(h5.join());
1720 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
1721 >                   Objects.equals(inc(v2), h4.join()));
1722 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
1723 >                   Objects.equals(inc(v2), h5.join()));
1724 >
1725          checkCompletedNormally(f, v1);
1726          checkCompletedNormally(g, v2);
1727 <        }
1728 <    }
1727 >        checkCompletedNormally(h0, inc(v1));
1728 >        checkCompletedNormally(h1, inc(v1));
1729 >        checkCompletedNormally(h2, inc(v1));
1730 >        checkCompletedNormally(h3, inc(v1));
1731 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
1732 >    }}
1733  
1734      /**
1735 <     * thenAcceptBoth result completes exceptionally if either source cancelled
1735 >     * applyToEither result completes exceptionally after exceptional
1736 >     * completion of either source
1737       */
1738 <    public void testThenAcceptBoth_sourceCancelled1() {
1738 >    public void testApplyToEither_exceptionalCompletion() {
1739          for (ExecutionMode m : ExecutionMode.values())
1740 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1741 <        for (Integer v1 : new Integer[] { 1, null }) {
1339 <
1740 >        for (Integer v1 : new Integer[] { 1, null })
1741 >    {
1742          final CompletableFuture<Integer> f = new CompletableFuture<>();
1743          final CompletableFuture<Integer> g = new CompletableFuture<>();
1744 <        final SubtractAction r = new SubtractAction();
1745 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1744 >        final CFException ex = new CFException();
1745 >        final IncFunction[] rs = new IncFunction[6];
1746 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1747  
1748 <        assertTrue(f.cancel(mayInterruptIfRunning));
1749 <        checkIncomplete(h);
1748 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1749 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1750 >        checkIncomplete(h0);
1751 >        checkIncomplete(h1);
1752 >        rs[0].assertNotInvoked();
1753 >        rs[1].assertNotInvoked();
1754 >        f.completeExceptionally(ex);
1755 >        checkCompletedWithWrappedCFException(h0, ex);
1756 >        checkCompletedWithWrappedCFException(h1, ex);
1757 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1758 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1759 >        checkCompletedWithWrappedCFException(h2, ex);
1760 >        checkCompletedWithWrappedCFException(h3, ex);
1761          g.complete(v1);
1762  
1763 <        checkCompletedWithWrappedCancellationException(h);
1764 <        checkCancelled(f);
1765 <        assertFalse(r.ran());
1766 <        checkCompletedNormally(g, v1);
1763 >        // unspecified behavior - both source completions available
1764 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1765 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1766 >        try {
1767 >            assertEquals(inc(v1), h4.join());
1768 >            rs[4].assertValue(inc(v1));
1769 >        } catch (CompletionException ok) {
1770 >            checkCompletedWithWrappedCFException(h4, ex);
1771 >            rs[4].assertNotInvoked();
1772 >        }
1773 >        try {
1774 >            assertEquals(inc(v1), h5.join());
1775 >            rs[5].assertValue(inc(v1));
1776 >        } catch (CompletionException ok) {
1777 >            checkCompletedWithWrappedCFException(h5, ex);
1778 >            rs[5].assertNotInvoked();
1779          }
1354    }
1355
1356    public void testThenAcceptBoth_sourceCancelled2() {
1357        for (ExecutionMode m : ExecutionMode.values())
1358        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1359        for (Integer v1 : new Integer[] { 1, null }) {
1780  
1781 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1782 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1783 <        final SubtractAction r = new SubtractAction();
1784 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1785 <
1786 <        assertTrue(g.cancel(mayInterruptIfRunning));
1787 <        checkIncomplete(h);
1788 <        f.complete(v1);
1789 <
1370 <        checkCompletedWithWrappedCancellationException(h);
1371 <        checkCancelled(g);
1372 <        assertFalse(r.ran());
1373 <        checkCompletedNormally(f, v1);
1374 <        }
1375 <    }
1781 >        checkCompletedWithWrappedCFException(f, ex);
1782 >        checkCompletedNormally(g, v1);
1783 >        checkCompletedWithWrappedCFException(h0, ex);
1784 >        checkCompletedWithWrappedCFException(h1, ex);
1785 >        checkCompletedWithWrappedCFException(h2, ex);
1786 >        checkCompletedWithWrappedCFException(h3, ex);
1787 >        checkCompletedWithWrappedCFException(h4, ex);
1788 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1789 >    }}
1790  
1791 <    public void testThenAcceptBoth_sourceCancelled3() {
1791 >    public void testApplyToEither_exceptionalCompletion2() {
1792          for (ExecutionMode m : ExecutionMode.values())
1793 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1794 <        for (Integer v1 : new Integer[] { 1, null }) {
1795 <
1793 >        for (boolean fFirst : new boolean[] { true, false })
1794 >        for (Integer v1 : new Integer[] { 1, null })
1795 >    {
1796          final CompletableFuture<Integer> f = new CompletableFuture<>();
1797          final CompletableFuture<Integer> g = new CompletableFuture<>();
1798 <        final SubtractAction r = new SubtractAction();
1798 >        final CFException ex = new CFException();
1799 >        final IncFunction[] rs = new IncFunction[6];
1800 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1801  
1802 <        assertTrue(g.cancel(mayInterruptIfRunning));
1803 <        f.complete(v1);
1804 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1802 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1803 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1804 >        if (fFirst) {
1805 >            f.complete(v1);
1806 >            g.completeExceptionally(ex);
1807 >        } else {
1808 >            g.completeExceptionally(ex);
1809 >            f.complete(v1);
1810 >        }
1811 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1812 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1813 >
1814 >        // unspecified behavior - both source completions available
1815 >        try {
1816 >            assertEquals(inc(v1), h0.join());
1817 >            rs[0].assertValue(inc(v1));
1818 >        } catch (CompletionException ok) {
1819 >            checkCompletedWithWrappedCFException(h0, ex);
1820 >            rs[0].assertNotInvoked();
1821 >        }
1822 >        try {
1823 >            assertEquals(inc(v1), h1.join());
1824 >            rs[1].assertValue(inc(v1));
1825 >        } catch (CompletionException ok) {
1826 >            checkCompletedWithWrappedCFException(h1, ex);
1827 >            rs[1].assertNotInvoked();
1828 >        }
1829 >        try {
1830 >            assertEquals(inc(v1), h2.join());
1831 >            rs[2].assertValue(inc(v1));
1832 >        } catch (CompletionException ok) {
1833 >            checkCompletedWithWrappedCFException(h2, ex);
1834 >            rs[2].assertNotInvoked();
1835 >        }
1836 >        try {
1837 >            assertEquals(inc(v1), h3.join());
1838 >            rs[3].assertValue(inc(v1));
1839 >        } catch (CompletionException ok) {
1840 >            checkCompletedWithWrappedCFException(h3, ex);
1841 >            rs[3].assertNotInvoked();
1842 >        }
1843  
1390        checkCompletedWithWrappedCancellationException(h);
1391        checkCancelled(g);
1392        assertFalse(r.ran());
1844          checkCompletedNormally(f, v1);
1845 <        }
1846 <    }
1845 >        checkCompletedWithWrappedCFException(g, ex);
1846 >    }}
1847  
1848 <    public void testThenAcceptBoth_sourceCancelled4() {
1848 >    /**
1849 >     * applyToEither result completes exceptionally if either source cancelled
1850 >     */
1851 >    public void testApplyToEither_sourceCancelled() {
1852          for (ExecutionMode m : ExecutionMode.values())
1853          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1854 <        for (Integer v1 : new Integer[] { 1, null }) {
1855 <
1854 >        for (Integer v1 : new Integer[] { 1, null })
1855 >    {
1856          final CompletableFuture<Integer> f = new CompletableFuture<>();
1857          final CompletableFuture<Integer> g = new CompletableFuture<>();
1858 <        final SubtractAction r = new SubtractAction();
1858 >        final IncFunction[] rs = new IncFunction[6];
1859 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1860  
1861 <        assertTrue(f.cancel(mayInterruptIfRunning));
1861 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1862 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1863 >        checkIncomplete(h0);
1864 >        checkIncomplete(h1);
1865 >        rs[0].assertNotInvoked();
1866 >        rs[1].assertNotInvoked();
1867 >        f.cancel(mayInterruptIfRunning);
1868 >        checkCompletedWithWrappedCancellationException(h0);
1869 >        checkCompletedWithWrappedCancellationException(h1);
1870 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1871 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1872 >        checkCompletedWithWrappedCancellationException(h2);
1873 >        checkCompletedWithWrappedCancellationException(h3);
1874          g.complete(v1);
1408        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1875  
1876 <        checkCompletedWithWrappedCancellationException(h);
1876 >        // unspecified behavior - both source completions available
1877 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1878 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1879 >        try {
1880 >            assertEquals(inc(v1), h4.join());
1881 >            rs[4].assertValue(inc(v1));
1882 >        } catch (CompletionException ok) {
1883 >            checkCompletedWithWrappedCancellationException(h4);
1884 >            rs[4].assertNotInvoked();
1885 >        }
1886 >        try {
1887 >            assertEquals(inc(v1), h5.join());
1888 >            rs[5].assertValue(inc(v1));
1889 >        } catch (CompletionException ok) {
1890 >            checkCompletedWithWrappedCancellationException(h5);
1891 >            rs[5].assertNotInvoked();
1892 >        }
1893 >
1894          checkCancelled(f);
1412        assertFalse(r.ran());
1895          checkCompletedNormally(g, v1);
1896 <        }
1897 <    }
1896 >        checkCompletedWithWrappedCancellationException(h0);
1897 >        checkCompletedWithWrappedCancellationException(h1);
1898 >        checkCompletedWithWrappedCancellationException(h2);
1899 >        checkCompletedWithWrappedCancellationException(h3);
1900 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1901 >    }}
1902  
1903 <    /**
1418 <     * runAfterBoth result completes normally after normal
1419 <     * completion of sources
1420 <     */
1421 <    public void testRunAfterBoth_normalCompletion1() {
1903 >    public void testApplyToEither_sourceCancelled2() {
1904          for (ExecutionMode m : ExecutionMode.values())
1905 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1906 +        for (boolean fFirst : new boolean[] { true, false })
1907          for (Integer v1 : new Integer[] { 1, null })
1908 <        for (Integer v2 : new Integer[] { 2, null }) {
1425 <
1908 >    {
1909          final CompletableFuture<Integer> f = new CompletableFuture<>();
1910          final CompletableFuture<Integer> g = new CompletableFuture<>();
1911 <        final Noop r = new Noop();
1912 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1430 <
1431 <        f.complete(v1);
1432 <        checkIncomplete(h);
1433 <        assertFalse(r.ran);
1434 <        g.complete(v2);
1911 >        final IncFunction[] rs = new IncFunction[6];
1912 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1913  
1914 <        checkCompletedNormally(h, null);
1915 <        assertTrue(r.ran);
1916 <        checkCompletedNormally(f, v1);
1917 <        checkCompletedNormally(g, v2);
1914 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1915 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1916 >        if (fFirst) {
1917 >            f.complete(v1);
1918 >            g.cancel(mayInterruptIfRunning);
1919 >        } else {
1920 >            g.cancel(mayInterruptIfRunning);
1921 >            f.complete(v1);
1922          }
1923 <    }
1923 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1924 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1925  
1926 <    public void testRunAfterBoth_normalCompletion2() {
1927 <        for (ExecutionMode m : ExecutionMode.values())
1928 <        for (Integer v1 : new Integer[] { 1, null })
1929 <        for (Integer v2 : new Integer[] { 2, null }) {
1930 <
1931 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1932 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1933 <        final Noop r = new Noop();
1934 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1935 <
1936 <        g.complete(v2);
1937 <        checkIncomplete(h);
1938 <        assertFalse(r.ran);
1939 <        f.complete(v1);
1926 >        // unspecified behavior - both source completions available
1927 >        try {
1928 >            assertEquals(inc(v1), h0.join());
1929 >            rs[0].assertValue(inc(v1));
1930 >        } catch (CompletionException ok) {
1931 >            checkCompletedWithWrappedCancellationException(h0);
1932 >            rs[0].assertNotInvoked();
1933 >        }
1934 >        try {
1935 >            assertEquals(inc(v1), h1.join());
1936 >            rs[1].assertValue(inc(v1));
1937 >        } catch (CompletionException ok) {
1938 >            checkCompletedWithWrappedCancellationException(h1);
1939 >            rs[1].assertNotInvoked();
1940 >        }
1941 >        try {
1942 >            assertEquals(inc(v1), h2.join());
1943 >            rs[2].assertValue(inc(v1));
1944 >        } catch (CompletionException ok) {
1945 >            checkCompletedWithWrappedCancellationException(h2);
1946 >            rs[2].assertNotInvoked();
1947 >        }
1948 >        try {
1949 >            assertEquals(inc(v1), h3.join());
1950 >            rs[3].assertValue(inc(v1));
1951 >        } catch (CompletionException ok) {
1952 >            checkCompletedWithWrappedCancellationException(h3);
1953 >            rs[3].assertNotInvoked();
1954 >        }
1955  
1458        checkCompletedNormally(h, null);
1459        assertTrue(r.ran);
1956          checkCompletedNormally(f, v1);
1957 <        checkCompletedNormally(g, v2);
1958 <        }
1463 <    }
1957 >        checkCancelled(g);
1958 >    }}
1959  
1960 <    public void testRunAfterBoth_normalCompletion3() {
1960 >    /**
1961 >     * applyToEither result completes exceptionally if action does
1962 >     */
1963 >    public void testApplyToEither_actionFailed() {
1964          for (ExecutionMode m : ExecutionMode.values())
1965          for (Integer v1 : new Integer[] { 1, null })
1966 <        for (Integer v2 : new Integer[] { 2, null }) {
1967 <
1966 >        for (Integer v2 : new Integer[] { 2, null })
1967 >    {
1968          final CompletableFuture<Integer> f = new CompletableFuture<>();
1969          final CompletableFuture<Integer> g = new CompletableFuture<>();
1970 <        final Noop r = new Noop();
1970 >        final FailingFunction[] rs = new FailingFunction[6];
1971 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1972 >
1973 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1974 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1975 >        f.complete(v1);
1976 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1977 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1978 >        checkCompletedWithWrappedCFException(h0);
1979 >        checkCompletedWithWrappedCFException(h1);
1980 >        checkCompletedWithWrappedCFException(h2);
1981 >        checkCompletedWithWrappedCFException(h3);
1982 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
1983  
1984          g.complete(v2);
1475        f.complete(v1);
1476        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1985  
1986 <        checkCompletedNormally(h, null);
1987 <        assertTrue(r.ran);
1986 >        // unspecified behavior - both source completions available
1987 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1988 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1989 >
1990 >        checkCompletedWithWrappedCFException(h4);
1991 >        assertTrue(Objects.equals(v1, rs[4].value) ||
1992 >                   Objects.equals(v2, rs[4].value));
1993 >        checkCompletedWithWrappedCFException(h5);
1994 >        assertTrue(Objects.equals(v1, rs[5].value) ||
1995 >                   Objects.equals(v2, rs[5].value));
1996 >
1997          checkCompletedNormally(f, v1);
1998          checkCompletedNormally(g, v2);
1999 <        }
1483 <    }
1999 >    }}
2000  
2001 <    public void testRunAfterBoth_normalCompletion4() {
2001 >    /**
2002 >     * acceptEither result completes normally after normal completion
2003 >     * of either source
2004 >     */
2005 >    public void testAcceptEither_normalCompletion() {
2006          for (ExecutionMode m : ExecutionMode.values())
2007          for (Integer v1 : new Integer[] { 1, null })
2008 <        for (Integer v2 : new Integer[] { 2, null }) {
2009 <
2008 >        for (Integer v2 : new Integer[] { 2, null })
2009 >    {
2010          final CompletableFuture<Integer> f = new CompletableFuture<>();
2011          final CompletableFuture<Integer> g = new CompletableFuture<>();
2012 <        final Noop r = new Noop();
2012 >        final NoopConsumer[] rs = new NoopConsumer[6];
2013 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2014  
2015 <        f.complete(v1);
2015 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2016 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2017 >        checkIncomplete(h0);
2018 >        checkIncomplete(h1);
2019 >        rs[0].assertNotInvoked();
2020 >        rs[1].assertNotInvoked();
2021 >        f.complete(v1);
2022 >        checkCompletedNormally(h0, null);
2023 >        checkCompletedNormally(h1, null);
2024 >        rs[0].assertValue(v1);
2025 >        rs[1].assertValue(v1);
2026 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2027 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2028 >        checkCompletedNormally(h2, null);
2029 >        checkCompletedNormally(h3, null);
2030 >        rs[2].assertValue(v1);
2031 >        rs[3].assertValue(v1);
2032          g.complete(v2);
1496        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2033  
2034 <        checkCompletedNormally(h, null);
2035 <        assertTrue(r.ran);
2034 >        // unspecified behavior - both source completions available
2035 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2036 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2037 >        checkCompletedNormally(h4, null);
2038 >        checkCompletedNormally(h5, null);
2039 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2040 >                   Objects.equals(v2, rs[4].value));
2041 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2042 >                   Objects.equals(v2, rs[5].value));
2043 >
2044          checkCompletedNormally(f, v1);
2045          checkCompletedNormally(g, v2);
2046 <        }
2047 <    }
2046 >        checkCompletedNormally(h0, null);
2047 >        checkCompletedNormally(h1, null);
2048 >        checkCompletedNormally(h2, null);
2049 >        checkCompletedNormally(h3, null);
2050 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2051 >    }}
2052  
2053      /**
2054 <     * runAfterBoth result completes exceptionally after exceptional
2054 >     * acceptEither result completes exceptionally after exceptional
2055       * completion of either source
2056       */
2057 <    public void testRunAfterBoth_exceptionalCompletion1() {
2057 >    public void testAcceptEither_exceptionalCompletion() {
2058          for (ExecutionMode m : ExecutionMode.values())
2059 <        for (Integer v1 : new Integer[] { 1, null }) {
2060 <
2059 >        for (Integer v1 : new Integer[] { 1, null })
2060 >    {
2061          final CompletableFuture<Integer> f = new CompletableFuture<>();
2062          final CompletableFuture<Integer> g = new CompletableFuture<>();
1515        final Noop r = new Noop();
1516        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2063          final CFException ex = new CFException();
2064 +        final NoopConsumer[] rs = new NoopConsumer[6];
2065 +        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2066  
2067 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2068 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2069 +        checkIncomplete(h0);
2070 +        checkIncomplete(h1);
2071 +        rs[0].assertNotInvoked();
2072 +        rs[1].assertNotInvoked();
2073          f.completeExceptionally(ex);
2074 <        checkIncomplete(h);
2074 >        checkCompletedWithWrappedCFException(h0, ex);
2075 >        checkCompletedWithWrappedCFException(h1, ex);
2076 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2077 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2078 >        checkCompletedWithWrappedCFException(h2, ex);
2079 >        checkCompletedWithWrappedCFException(h3, ex);
2080 >
2081          g.complete(v1);
2082  
2083 <        checkCompletedWithWrappedCFException(h, ex);
2083 >        // unspecified behavior - both source completions available
2084 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2085 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2086 >        try {
2087 >            assertNull(h4.join());
2088 >            rs[4].assertValue(v1);
2089 >        } catch (CompletionException ok) {
2090 >            checkCompletedWithWrappedCFException(h4, ex);
2091 >            rs[4].assertNotInvoked();
2092 >        }
2093 >        try {
2094 >            assertNull(h5.join());
2095 >            rs[5].assertValue(v1);
2096 >        } catch (CompletionException ok) {
2097 >            checkCompletedWithWrappedCFException(h5, ex);
2098 >            rs[5].assertNotInvoked();
2099 >        }
2100 >
2101          checkCompletedWithWrappedCFException(f, ex);
1525        assertFalse(r.ran);
2102          checkCompletedNormally(g, v1);
2103 <        }
2104 <    }
2103 >        checkCompletedWithWrappedCFException(h0, ex);
2104 >        checkCompletedWithWrappedCFException(h1, ex);
2105 >        checkCompletedWithWrappedCFException(h2, ex);
2106 >        checkCompletedWithWrappedCFException(h3, ex);
2107 >        checkCompletedWithWrappedCFException(h4, ex);
2108 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2109 >    }}
2110  
2111 <    public void testRunAfterBoth_exceptionalCompletion2() {
2111 >    /**
2112 >     * acceptEither result completes exceptionally if either source cancelled
2113 >     */
2114 >    public void testAcceptEither_sourceCancelled() {
2115          for (ExecutionMode m : ExecutionMode.values())
2116 <        for (Integer v1 : new Integer[] { 1, null }) {
2117 <
2116 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2117 >        for (Integer v1 : new Integer[] { 1, null })
2118 >    {
2119          final CompletableFuture<Integer> f = new CompletableFuture<>();
2120          final CompletableFuture<Integer> g = new CompletableFuture<>();
2121 <        final Noop r = new Noop();
2122 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1538 <        final CFException ex = new CFException();
2121 >        final NoopConsumer[] rs = new NoopConsumer[6];
2122 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2123  
2124 <        g.completeExceptionally(ex);
2125 <        checkIncomplete(h);
2126 <        f.complete(v1);
2124 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2125 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2126 >        checkIncomplete(h0);
2127 >        checkIncomplete(h1);
2128 >        rs[0].assertNotInvoked();
2129 >        rs[1].assertNotInvoked();
2130 >        f.cancel(mayInterruptIfRunning);
2131 >        checkCompletedWithWrappedCancellationException(h0);
2132 >        checkCompletedWithWrappedCancellationException(h1);
2133 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2134 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2135 >        checkCompletedWithWrappedCancellationException(h2);
2136 >        checkCompletedWithWrappedCancellationException(h3);
2137  
2138 <        checkCompletedWithWrappedCFException(h, ex);
1545 <        checkCompletedWithWrappedCFException(g, ex);
1546 <        assertFalse(r.ran);
1547 <        checkCompletedNormally(f, v1);
1548 <        }
1549 <    }
1550 <
1551 <    public void testRunAfterBoth_exceptionalCompletion3() {
1552 <        for (ExecutionMode m : ExecutionMode.values())
1553 <        for (Integer v1 : new Integer[] { 1, null }) {
1554 <
1555 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1556 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1557 <        final Noop r = new Noop();
1558 <        final CFException ex = new CFException();
1559 <
1560 <        g.completeExceptionally(ex);
1561 <        f.complete(v1);
1562 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2138 >        g.complete(v1);
2139  
2140 <        checkCompletedWithWrappedCFException(h, ex);
2141 <        checkCompletedWithWrappedCFException(g, ex);
2142 <        assertFalse(r.ran);
2143 <        checkCompletedNormally(f, v1);
2140 >        // unspecified behavior - both source completions available
2141 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2142 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2143 >        try {
2144 >            assertNull(h4.join());
2145 >            rs[4].assertValue(v1);
2146 >        } catch (CompletionException ok) {
2147 >            checkCompletedWithWrappedCancellationException(h4);
2148 >            rs[4].assertNotInvoked();
2149 >        }
2150 >        try {
2151 >            assertNull(h5.join());
2152 >            rs[5].assertValue(v1);
2153 >        } catch (CompletionException ok) {
2154 >            checkCompletedWithWrappedCancellationException(h5);
2155 >            rs[5].assertNotInvoked();
2156          }
1569    }
2157  
2158 <    public void testRunAfterBoth_exceptionalCompletion4() {
1572 <        for (ExecutionMode m : ExecutionMode.values())
1573 <        for (Integer v1 : new Integer[] { 1, null }) {
1574 <
1575 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1576 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1577 <        final Noop r = new Noop();
1578 <        final CFException ex = new CFException();
1579 <
1580 <        f.completeExceptionally(ex);
1581 <        g.complete(v1);
1582 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1583 <
1584 <        checkCompletedWithWrappedCFException(h, ex);
1585 <        checkCompletedWithWrappedCFException(f, ex);
1586 <        assertFalse(r.ran);
2158 >        checkCancelled(f);
2159          checkCompletedNormally(g, v1);
2160 <        }
2161 <    }
2160 >        checkCompletedWithWrappedCancellationException(h0);
2161 >        checkCompletedWithWrappedCancellationException(h1);
2162 >        checkCompletedWithWrappedCancellationException(h2);
2163 >        checkCompletedWithWrappedCancellationException(h3);
2164 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2165 >    }}
2166  
2167      /**
2168 <     * runAfterBoth result completes exceptionally if action does
2168 >     * acceptEither result completes exceptionally if action does
2169       */
2170 <    public void testRunAfterBoth_actionFailed1() {
2170 >    public void testAcceptEither_actionFailed() {
2171          for (ExecutionMode m : ExecutionMode.values())
2172          for (Integer v1 : new Integer[] { 1, null })
2173 <        for (Integer v2 : new Integer[] { 2, null }) {
2174 <
2173 >        for (Integer v2 : new Integer[] { 2, null })
2174 >    {
2175          final CompletableFuture<Integer> f = new CompletableFuture<>();
2176          final CompletableFuture<Integer> g = new CompletableFuture<>();
2177 <        final FailingNoop r = new FailingNoop();
2178 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2177 >        final FailingConsumer[] rs = new FailingConsumer[6];
2178 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2179 >
2180 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2181 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2182 >        f.complete(v1);
2183 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2184 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2185 >        checkCompletedWithWrappedCFException(h0);
2186 >        checkCompletedWithWrappedCFException(h1);
2187 >        checkCompletedWithWrappedCFException(h2);
2188 >        checkCompletedWithWrappedCFException(h3);
2189 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2190  
1604        f.complete(v1);
1605        checkIncomplete(h);
2191          g.complete(v2);
2192  
2193 <        checkCompletedWithWrappedCFException(h);
2193 >        // unspecified behavior - both source completions available
2194 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2195 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2196 >
2197 >        checkCompletedWithWrappedCFException(h4);
2198 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2199 >                   Objects.equals(v2, rs[4].value));
2200 >        checkCompletedWithWrappedCFException(h5);
2201 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2202 >                   Objects.equals(v2, rs[5].value));
2203 >
2204          checkCompletedNormally(f, v1);
2205          checkCompletedNormally(g, v2);
2206 <        }
1612 <    }
2206 >    }}
2207  
2208 <    public void testRunAfterBoth_actionFailed2() {
2208 >    /**
2209 >     * runAfterEither result completes normally after normal completion
2210 >     * of either source
2211 >     */
2212 >    public void testRunAfterEither_normalCompletion() {
2213          for (ExecutionMode m : ExecutionMode.values())
2214          for (Integer v1 : new Integer[] { 1, null })
2215 <        for (Integer v2 : new Integer[] { 2, null }) {
2216 <
2215 >        for (Integer v2 : new Integer[] { 2, null })
2216 >    {
2217          final CompletableFuture<Integer> f = new CompletableFuture<>();
2218          final CompletableFuture<Integer> g = new CompletableFuture<>();
2219 <        final FailingNoop r = new FailingNoop();
2220 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2219 >        final Noop[] rs = new Noop[6];
2220 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2221 >
2222 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2223 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2224 >        checkIncomplete(h0);
2225 >        checkIncomplete(h1);
2226 >        rs[0].assertNotInvoked();
2227 >        rs[1].assertNotInvoked();
2228 >        f.complete(v1);
2229 >        checkCompletedNormally(h0, null);
2230 >        checkCompletedNormally(h1, null);
2231 >        rs[0].assertInvoked();
2232 >        rs[1].assertInvoked();
2233 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2234 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2235 >        checkCompletedNormally(h2, null);
2236 >        checkCompletedNormally(h3, null);
2237 >        rs[2].assertInvoked();
2238 >        rs[3].assertInvoked();
2239  
2240          g.complete(v2);
1625        checkIncomplete(h);
1626        f.complete(v1);
2241  
2242 <        checkCompletedWithWrappedCFException(h);
2242 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2243 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2244 >
2245          checkCompletedNormally(f, v1);
2246          checkCompletedNormally(g, v2);
2247 <        }
2248 <    }
2247 >        checkCompletedNormally(h0, null);
2248 >        checkCompletedNormally(h1, null);
2249 >        checkCompletedNormally(h2, null);
2250 >        checkCompletedNormally(h3, null);
2251 >        checkCompletedNormally(h4, null);
2252 >        checkCompletedNormally(h5, null);
2253 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2254 >    }}
2255  
2256      /**
2257 <     * runAfterBoth result completes exceptionally if either source cancelled
2257 >     * runAfterEither result completes exceptionally after exceptional
2258 >     * completion of either source
2259       */
2260 <    public void testRunAfterBoth_sourceCancelled1() {
2260 >    public void testRunAfterEither_exceptionalCompletion() {
2261          for (ExecutionMode m : ExecutionMode.values())
2262 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2263 <        for (Integer v1 : new Integer[] { 1, null }) {
1641 <
2262 >        for (Integer v1 : new Integer[] { 1, null })
2263 >    {
2264          final CompletableFuture<Integer> f = new CompletableFuture<>();
2265          final CompletableFuture<Integer> g = new CompletableFuture<>();
2266 <        final Noop r = new Noop();
2267 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2266 >        final CFException ex = new CFException();
2267 >        final Noop[] rs = new Noop[6];
2268 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2269 >
2270 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2271 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2272 >        checkIncomplete(h0);
2273 >        checkIncomplete(h1);
2274 >        rs[0].assertNotInvoked();
2275 >        rs[1].assertNotInvoked();
2276 >        f.completeExceptionally(ex);
2277 >        checkCompletedWithWrappedCFException(h0, ex);
2278 >        checkCompletedWithWrappedCFException(h1, ex);
2279 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2280 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2281 >        checkCompletedWithWrappedCFException(h2, ex);
2282 >        checkCompletedWithWrappedCFException(h3, ex);
2283  
1647        assertTrue(f.cancel(mayInterruptIfRunning));
1648        checkIncomplete(h);
2284          g.complete(v1);
2285  
2286 <        checkCompletedWithWrappedCancellationException(h);
2287 <        checkCancelled(f);
2288 <        assertFalse(r.ran);
2289 <        checkCompletedNormally(g, v1);
2286 >        // unspecified behavior - both source completions available
2287 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2288 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2289 >        try {
2290 >            assertNull(h4.join());
2291 >            rs[4].assertInvoked();
2292 >        } catch (CompletionException ok) {
2293 >            checkCompletedWithWrappedCFException(h4, ex);
2294 >            rs[4].assertNotInvoked();
2295 >        }
2296 >        try {
2297 >            assertNull(h5.join());
2298 >            rs[5].assertInvoked();
2299 >        } catch (CompletionException ok) {
2300 >            checkCompletedWithWrappedCFException(h5, ex);
2301 >            rs[5].assertNotInvoked();
2302          }
1656    }
1657
1658    public void testRunAfterBoth_sourceCancelled2() {
1659        for (ExecutionMode m : ExecutionMode.values())
1660        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1661        for (Integer v1 : new Integer[] { 1, null }) {
1662
1663        final CompletableFuture<Integer> f = new CompletableFuture<>();
1664        final CompletableFuture<Integer> g = new CompletableFuture<>();
1665        final Noop r = new Noop();
1666        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1667
1668        assertTrue(g.cancel(mayInterruptIfRunning));
1669        checkIncomplete(h);
1670        f.complete(v1);
2303  
2304 <        checkCompletedWithWrappedCancellationException(h);
2305 <        checkCancelled(g);
2306 <        assertFalse(r.ran);
2307 <        checkCompletedNormally(f, v1);
2308 <        }
2309 <    }
2304 >        checkCompletedWithWrappedCFException(f, ex);
2305 >        checkCompletedNormally(g, v1);
2306 >        checkCompletedWithWrappedCFException(h0, ex);
2307 >        checkCompletedWithWrappedCFException(h1, ex);
2308 >        checkCompletedWithWrappedCFException(h2, ex);
2309 >        checkCompletedWithWrappedCFException(h3, ex);
2310 >        checkCompletedWithWrappedCFException(h4, ex);
2311 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2312 >    }}
2313  
2314 <    public void testRunAfterBoth_sourceCancelled3() {
2314 >    /**
2315 >     * runAfterEither result completes exceptionally if either source cancelled
2316 >     */
2317 >    public void testRunAfterEither_sourceCancelled() {
2318          for (ExecutionMode m : ExecutionMode.values())
2319          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2320 <        for (Integer v1 : new Integer[] { 1, null }) {
2321 <
2320 >        for (Integer v1 : new Integer[] { 1, null })
2321 >    {
2322          final CompletableFuture<Integer> f = new CompletableFuture<>();
2323          final CompletableFuture<Integer> g = new CompletableFuture<>();
2324 <        final Noop r = new Noop();
2324 >        final Noop[] rs = new Noop[6];
2325 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2326  
2327 <        assertTrue(g.cancel(mayInterruptIfRunning));
2328 <        f.complete(v1);
2329 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2330 <
2331 <        checkCompletedWithWrappedCancellationException(h);
2332 <        checkCancelled(g);
2333 <        assertFalse(r.ran);
2334 <        checkCompletedNormally(f, v1);
2335 <        }
2336 <    }
2337 <
2338 <    public void testRunAfterBoth_sourceCancelled4() {
2339 <        for (ExecutionMode m : ExecutionMode.values())
1701 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1702 <        for (Integer v1 : new Integer[] { 1, null }) {
1703 <
1704 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1705 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1706 <        final Noop r = new Noop();
2327 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2328 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2329 >        checkIncomplete(h0);
2330 >        checkIncomplete(h1);
2331 >        rs[0].assertNotInvoked();
2332 >        rs[1].assertNotInvoked();
2333 >        f.cancel(mayInterruptIfRunning);
2334 >        checkCompletedWithWrappedCancellationException(h0);
2335 >        checkCompletedWithWrappedCancellationException(h1);
2336 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2337 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2338 >        checkCompletedWithWrappedCancellationException(h2);
2339 >        checkCompletedWithWrappedCancellationException(h3);
2340  
1708        assertTrue(f.cancel(mayInterruptIfRunning));
2341          g.complete(v1);
1710        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2342  
2343 <        checkCompletedWithWrappedCancellationException(h);
2344 <        checkCancelled(f);
2345 <        assertFalse(r.ran);
2346 <        checkCompletedNormally(g, v1);
2343 >        // unspecified behavior - both source completions available
2344 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2345 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2346 >        try {
2347 >            assertNull(h4.join());
2348 >            rs[4].assertInvoked();
2349 >        } catch (CompletionException ok) {
2350 >            checkCompletedWithWrappedCancellationException(h4);
2351 >            rs[4].assertNotInvoked();
2352 >        }
2353 >        try {
2354 >            assertNull(h5.join());
2355 >            rs[5].assertInvoked();
2356 >        } catch (CompletionException ok) {
2357 >            checkCompletedWithWrappedCancellationException(h5);
2358 >            rs[5].assertNotInvoked();
2359          }
1717    }
1718
1719    /**
1720     * applyToEither result completes normally after normal completion
1721     * of either source
1722     */
1723    public void testApplyToEither() {
1724        CompletableFuture<Integer> f = new CompletableFuture<>();
1725        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1726        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1727        f.complete(one);
1728        checkCompletedNormally(g, two);
1729        f2.complete(one);
1730        checkCompletedNormally(g, two);
1731
1732        f = new CompletableFuture<>();
1733        f.complete(one);
1734        f2 = new CompletableFuture<>();
1735        g = f.applyToEither(f2, inc);
1736        checkCompletedNormally(g, two);
1737    }
1738
1739    /**
1740     * applyToEither result completes exceptionally after exceptional
1741     * completion of either source
1742     */
1743    public void testApplyToEither2() {
1744        CompletableFuture<Integer> f = new CompletableFuture<>();
1745        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1746        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1747        f.completeExceptionally(new CFException());
1748        f2.complete(one);
1749        checkCompletedWithWrappedCFException(g);
1750
1751        f = new CompletableFuture<>();
1752        f2 = new CompletableFuture<>();
1753        f2.completeExceptionally(new CFException());
1754        g = f.applyToEither(f2, inc);
1755        checkCompletedWithWrappedCFException(g);
1756    }
1757
1758    /**
1759     * applyToEither result completes exceptionally if action does
1760     */
1761    public void testApplyToEither3() {
1762        CompletableFuture<Integer> f = new CompletableFuture<>();
1763        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1764        FailingFunction r = new FailingFunction();
1765        CompletableFuture<Integer> g = f.applyToEither(f2, r);
1766        f2.complete(two);
1767        checkCompletedWithWrappedCFException(g);
1768    }
2360  
2361 <    /**
2362 <     * applyToEither result completes exceptionally if either source cancelled
2363 <     */
2364 <    public void testApplyToEither4() {
2365 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2366 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2367 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
2368 <        assertTrue(f.cancel(true));
1778 <        checkCompletedWithWrappedCancellationException(g);
1779 <        f = new CompletableFuture<>();
1780 <        f2 = new CompletableFuture<>();
1781 <        assertTrue(f2.cancel(true));
1782 <        checkCompletedWithWrappedCancellationException(g);
1783 <    }
1784 <
1785 <    /**
1786 <     * acceptEither result completes normally after normal completion
1787 <     * of either source
1788 <     */
1789 <    public void testAcceptEither() {
1790 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1791 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1792 <        IncAction r = new IncAction();
1793 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1794 <        f.complete(one);
1795 <        checkCompletedNormally(g, null);
1796 <        f2.complete(one);
1797 <        checkCompletedNormally(g, null);
1798 <        assertEquals(r.value, 2);
1799 <
1800 <        r = new IncAction();
1801 <        f = new CompletableFuture<>();
1802 <        f.complete(one);
1803 <        f2 = new CompletableFuture<>();
1804 <        g = f.acceptEither(f2, r);
1805 <        checkCompletedNormally(g, null);
1806 <        assertEquals(r.value, 2);
1807 <    }
1808 <
1809 <    /**
1810 <     * acceptEither result completes exceptionally after exceptional
1811 <     * completion of either source
1812 <     */
1813 <    public void testAcceptEither2() {
1814 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1815 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1816 <        IncAction r = new IncAction();
1817 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1818 <        f.completeExceptionally(new CFException());
1819 <        f2.complete(one);
1820 <        checkCompletedWithWrappedCFException(g);
1821 <
1822 <        r = new IncAction();
1823 <        f = new CompletableFuture<>();
1824 <        f2 = new CompletableFuture<>();
1825 <        f2.completeExceptionally(new CFException());
1826 <        g = f.acceptEither(f2, r);
1827 <        checkCompletedWithWrappedCFException(g);
1828 <    }
1829 <
1830 <    /**
1831 <     * acceptEither result completes exceptionally if action does
1832 <     */
1833 <    public void testAcceptEither3() {
1834 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1835 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1836 <        FailingConsumer r = new FailingConsumer();
1837 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1838 <        f2.complete(two);
1839 <        checkCompletedWithWrappedCFException(g);
1840 <    }
1841 <
1842 <    /**
1843 <     * acceptEither result completes exceptionally if either source cancelled
1844 <     */
1845 <    public void testAcceptEither4() {
1846 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1847 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1848 <        IncAction r = new IncAction();
1849 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1850 <        assertTrue(f.cancel(true));
1851 <        checkCompletedWithWrappedCancellationException(g);
1852 <        f = new CompletableFuture<>();
1853 <        f2 = new CompletableFuture<>();
1854 <        assertTrue(f2.cancel(true));
1855 <        checkCompletedWithWrappedCancellationException(g);
1856 <    }
1857 <
1858 <    /**
1859 <     * runAfterEither result completes normally after normal completion
1860 <     * of either source
1861 <     */
1862 <    public void testRunAfterEither() {
1863 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1864 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1865 <        Noop r = new Noop();
1866 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1867 <        f.complete(one);
1868 <        checkCompletedNormally(g, null);
1869 <        f2.complete(one);
1870 <        checkCompletedNormally(g, null);
1871 <        assertTrue(r.ran);
1872 <
1873 <        r = new Noop();
1874 <        f = new CompletableFuture<>();
1875 <        f.complete(one);
1876 <        f2 = new CompletableFuture<>();
1877 <        g = f.runAfterEither(f2, r);
1878 <        checkCompletedNormally(g, null);
1879 <        assertTrue(r.ran);
1880 <    }
1881 <
1882 <    /**
1883 <     * runAfterEither result completes exceptionally after exceptional
1884 <     * completion of either source
1885 <     */
1886 <    public void testRunAfterEither2() {
1887 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1888 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1889 <        Noop r = new Noop();
1890 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1891 <        f.completeExceptionally(new CFException());
1892 <        f2.complete(one);
1893 <        checkCompletedWithWrappedCFException(g);
1894 <
1895 <        r = new Noop();
1896 <        f = new CompletableFuture<>();
1897 <        f2 = new CompletableFuture<>();
1898 <        f2.completeExceptionally(new CFException());
1899 <        g = f.runAfterEither(f2, r);
1900 <        checkCompletedWithWrappedCFException(g);
1901 <    }
2361 >        checkCancelled(f);
2362 >        checkCompletedNormally(g, v1);
2363 >        checkCompletedWithWrappedCancellationException(h0);
2364 >        checkCompletedWithWrappedCancellationException(h1);
2365 >        checkCompletedWithWrappedCancellationException(h2);
2366 >        checkCompletedWithWrappedCancellationException(h3);
2367 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2368 >    }}
2369  
2370      /**
2371       * runAfterEither result completes exceptionally if action does
2372       */
2373 <    public void testRunAfterEither3() {
2374 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2375 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2376 <        FailingNoop r = new FailingNoop();
2377 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2378 <        f2.complete(two);
2379 <        checkCompletedWithWrappedCFException(g);
2380 <    }
2373 >    public void testRunAfterEither_actionFailed() {
2374 >        for (ExecutionMode m : ExecutionMode.values())
2375 >        for (Integer v1 : new Integer[] { 1, null })
2376 >        for (Integer v2 : new Integer[] { 2, null })
2377 >    {
2378 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2379 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2380 >        final FailingRunnable[] rs = new FailingRunnable[6];
2381 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2382  
2383 <    /**
2384 <     * runAfterEither result completes exceptionally if either source cancelled
2385 <     */
2386 <    public void testRunAfterEither4() {
2387 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2388 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2389 <        Noop r = new Noop();
2390 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2391 <        assertTrue(f.cancel(true));
2392 <        checkCompletedWithWrappedCancellationException(g);
2393 <        f = new CompletableFuture<>();
2394 <        f2 = new CompletableFuture<>();
2395 <        assertTrue(f2.cancel(true));
2396 <        checkCompletedWithWrappedCancellationException(g);
2397 <    }
2383 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2384 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2385 >        f.complete(v1);
2386 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2387 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2388 >        checkCompletedWithWrappedCFException(h0);
2389 >        checkCompletedWithWrappedCFException(h1);
2390 >        checkCompletedWithWrappedCFException(h2);
2391 >        checkCompletedWithWrappedCFException(h3);
2392 >        for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2393 >        g.complete(v2);
2394 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2395 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2396 >        checkCompletedWithWrappedCFException(h4);
2397 >        checkCompletedWithWrappedCFException(h5);
2398 >
2399 >        checkCompletedNormally(f, v1);
2400 >        checkCompletedNormally(g, v2);
2401 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2402 >    }}
2403  
2404      /**
2405       * thenCompose result completes normally after normal completion of source
2406       */
2407 <    public void testThenCompose() {
2408 <        CompletableFuture<Integer> f, g;
2409 <        CompletableFutureInc r;
2410 <
2411 <        f = new CompletableFuture<>();
2412 <        g = f.thenCompose(r = new CompletableFutureInc());
2413 <        f.complete(one);
2414 <        checkCompletedNormally(g, two);
2415 <        assertTrue(r.ran);
2407 >    public void testThenCompose_normalCompletion() {
2408 >        for (ExecutionMode m : ExecutionMode.values())
2409 >        for (boolean createIncomplete : new boolean[] { true, false })
2410 >        for (Integer v1 : new Integer[] { 1, null })
2411 >    {
2412 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2413 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2414 >        if (!createIncomplete) f.complete(v1);
2415 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2416 >        if (createIncomplete) f.complete(v1);
2417  
2418 <        f = new CompletableFuture<>();
2419 <        f.complete(one);
2420 <        g = f.thenCompose(r = new CompletableFutureInc());
2421 <        checkCompletedNormally(g, two);
1948 <        assertTrue(r.ran);
1949 <    }
2418 >        checkCompletedNormally(g, inc(v1));
2419 >        checkCompletedNormally(f, v1);
2420 >        r.assertInvoked();
2421 >    }}
2422  
2423      /**
2424       * thenCompose result completes exceptionally after exceptional
2425       * completion of source
2426       */
2427 <    public void testThenCompose2() {
2428 <        CompletableFuture<Integer> f, g;
2429 <        CompletableFutureInc r;
2430 <
2431 <        f = new CompletableFuture<>();
2432 <        g = f.thenCompose(r = new CompletableFutureInc());
2433 <        f.completeExceptionally(new CFException());
2434 <        checkCompletedWithWrappedCFException(g);
2427 >    public void testThenCompose_exceptionalCompletion() {
2428 >        for (ExecutionMode m : ExecutionMode.values())
2429 >        for (boolean createIncomplete : new boolean[] { true, false })
2430 >    {
2431 >        final CFException ex = new CFException();
2432 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2433 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2434 >        if (!createIncomplete) f.completeExceptionally(ex);
2435 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2436 >        if (createIncomplete) f.completeExceptionally(ex);
2437  
2438 <        f = new CompletableFuture<>();
2439 <        f.completeExceptionally(new CFException());
2440 <        g = f.thenCompose(r = new CompletableFutureInc());
2441 <        checkCompletedWithWrappedCFException(g);
1968 <    }
2438 >        checkCompletedWithWrappedCFException(g, ex);
2439 >        checkCompletedWithWrappedCFException(f, ex);
2440 >        r.assertNotInvoked();
2441 >    }}
2442  
2443      /**
2444       * thenCompose result completes exceptionally if action does
2445       */
2446 <    public void testThenCompose3() {
2447 <        CompletableFuture<Integer> f, g;
2448 <        FailingCompletableFutureFunction r;
2446 >    public void testThenCompose_actionFailed() {
2447 >        for (ExecutionMode m : ExecutionMode.values())
2448 >        for (boolean createIncomplete : new boolean[] { true, false })
2449 >        for (Integer v1 : new Integer[] { 1, null })
2450 >    {
2451 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2452 >        final FailingCompletableFutureFunction r
2453 >            = new FailingCompletableFutureFunction(m);
2454 >        if (!createIncomplete) f.complete(v1);
2455 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2456 >        if (createIncomplete) f.complete(v1);
2457  
1977        f = new CompletableFuture<>();
1978        g = f.thenCompose(r = new FailingCompletableFutureFunction());
1979        f.complete(one);
2458          checkCompletedWithWrappedCFException(g);
2459 <
2460 <        f = new CompletableFuture<>();
1983 <        f.complete(one);
1984 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
1985 <        checkCompletedWithWrappedCFException(g);
1986 <    }
2459 >        checkCompletedNormally(f, v1);
2460 >    }}
2461  
2462      /**
2463       * thenCompose result completes exceptionally if source cancelled
2464       */
2465 <    public void testThenCompose4() {
2466 <        CompletableFuture<Integer> f, g;
2467 <        CompletableFutureInc r;
2468 <
2469 <        f = new CompletableFuture<>();
2470 <        g = f.thenCompose(r = new CompletableFutureInc());
2471 <        assertTrue(f.cancel(true));
2472 <        checkCompletedWithWrappedCancellationException(g);
2473 <
2474 <        f = new CompletableFuture<>();
2475 <        assertTrue(f.cancel(true));
2476 <        g = f.thenCompose(r = new CompletableFutureInc());
2477 <        checkCompletedWithWrappedCancellationException(g);
2004 <    }
2005 <
2006 <    // asyncs
2007 <
2008 <    /**
2009 <     * thenRunAsync result completes normally after normal completion of source
2010 <     */
2011 <    public void testThenRunAsync() {
2012 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2013 <        Noop r = new Noop();
2014 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2015 <        f.complete(null);
2016 <        checkCompletedNormally(g, null);
2017 <
2018 <        // reordered version
2019 <        f = new CompletableFuture<>();
2020 <        f.complete(null);
2021 <        r = new Noop();
2022 <        g = f.thenRunAsync(r);
2023 <        checkCompletedNormally(g, null);
2024 <    }
2025 <
2026 <    /**
2027 <     * thenRunAsync result completes exceptionally after exceptional
2028 <     * completion of source
2029 <     */
2030 <    public void testThenRunAsync2() {
2031 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2032 <        Noop r = new Noop();
2033 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2034 <        f.completeExceptionally(new CFException());
2035 <        try {
2036 <            g.join();
2037 <            shouldThrow();
2038 <        } catch (CompletionException success) {}
2039 <        checkCompletedWithWrappedCFException(g);
2040 <    }
2041 <
2042 <    /**
2043 <     * thenRunAsync result completes exceptionally if action does
2044 <     */
2045 <    public void testThenRunAsync3() {
2046 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2047 <        FailingNoop r = new FailingNoop();
2048 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2049 <        f.complete(null);
2050 <        checkCompletedWithWrappedCFException(g);
2051 <    }
2052 <
2053 <    /**
2054 <     * thenRunAsync result completes exceptionally if source cancelled
2055 <     */
2056 <    public void testThenRunAsync4() {
2057 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2058 <        Noop r = new Noop();
2059 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2060 <        assertTrue(f.cancel(true));
2061 <        checkCompletedWithWrappedCancellationException(g);
2062 <    }
2063 <
2064 <    /**
2065 <     * thenApplyAsync result completes normally after normal completion of source
2066 <     */
2067 <    public void testThenApplyAsync() {
2068 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2069 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2070 <        f.complete(one);
2071 <        checkCompletedNormally(g, two);
2072 <    }
2073 <
2074 <    /**
2075 <     * thenApplyAsync result completes exceptionally after exceptional
2076 <     * completion of source
2077 <     */
2078 <    public void testThenApplyAsync2() {
2079 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2080 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2081 <        f.completeExceptionally(new CFException());
2082 <        checkCompletedWithWrappedCFException(g);
2083 <    }
2084 <
2085 <    /**
2086 <     * thenApplyAsync result completes exceptionally if action does
2087 <     */
2088 <    public void testThenApplyAsync3() {
2089 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2090 <        FailingFunction r = new FailingFunction();
2091 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2092 <        f.complete(null);
2093 <        checkCompletedWithWrappedCFException(g);
2094 <    }
2095 <
2096 <    /**
2097 <     * thenApplyAsync result completes exceptionally if source cancelled
2098 <     */
2099 <    public void testThenApplyAsync4() {
2100 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2101 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2102 <        assertTrue(f.cancel(true));
2103 <        checkCompletedWithWrappedCancellationException(g);
2104 <    }
2105 <
2106 <    /**
2107 <     * thenAcceptAsync result completes normally after normal
2108 <     * completion of source
2109 <     */
2110 <    public void testThenAcceptAsync() {
2111 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2112 <        IncAction r = new IncAction();
2113 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2114 <        f.complete(one);
2115 <        checkCompletedNormally(g, null);
2116 <        assertEquals(r.value, 2);
2117 <    }
2118 <
2119 <    /**
2120 <     * thenAcceptAsync result completes exceptionally after exceptional
2121 <     * completion of source
2122 <     */
2123 <    public void testThenAcceptAsync2() {
2124 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2125 <        IncAction r = new IncAction();
2126 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2127 <        f.completeExceptionally(new CFException());
2128 <        checkCompletedWithWrappedCFException(g);
2129 <    }
2130 <
2131 <    /**
2132 <     * thenAcceptAsync result completes exceptionally if action does
2133 <     */
2134 <    public void testThenAcceptAsync3() {
2135 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2136 <        FailingConsumer r = new FailingConsumer();
2137 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2138 <        f.complete(null);
2139 <        checkCompletedWithWrappedCFException(g);
2140 <    }
2141 <
2142 <    /**
2143 <     * thenAcceptAsync result completes exceptionally if source cancelled
2144 <     */
2145 <    public void testThenAcceptAsync4() {
2146 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2147 <        IncAction r = new IncAction();
2148 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2149 <        assertTrue(f.cancel(true));
2150 <        checkCompletedWithWrappedCancellationException(g);
2151 <    }
2152 <
2153 <    /**
2154 <     * applyToEitherAsync result completes normally after normal
2155 <     * completion of sources
2156 <     */
2157 <    public void testApplyToEitherAsync() {
2158 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2159 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2160 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2161 <        f.complete(one);
2162 <        checkCompletedNormally(g, two);
2163 <
2164 <        f = new CompletableFuture<>();
2165 <        f.complete(one);
2166 <        f2 = new CompletableFuture<>();
2167 <        g = f.applyToEitherAsync(f2, inc);
2168 <        checkCompletedNormally(g, two);
2169 <    }
2170 <
2171 <    /**
2172 <     * applyToEitherAsync result completes exceptionally after exceptional
2173 <     * completion of source
2174 <     */
2175 <    public void testApplyToEitherAsync2() {
2176 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2177 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2178 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2179 <        f.completeExceptionally(new CFException());
2180 <        checkCompletedWithWrappedCFException(g);
2181 <
2182 <        f = new CompletableFuture<>();
2183 <        f2 = new CompletableFuture<>();
2184 <        f2.completeExceptionally(new CFException());
2185 <        g = f.applyToEitherAsync(f2, inc);
2186 <        f.complete(one);
2187 <        checkCompletedWithWrappedCFException(g);
2188 <    }
2189 <
2190 <    /**
2191 <     * applyToEitherAsync result completes exceptionally if action does
2192 <     */
2193 <    public void testApplyToEitherAsync3() {
2194 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2195 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2196 <        FailingFunction r = new FailingFunction();
2197 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
2198 <        f.complete(one);
2199 <        checkCompletedWithWrappedCFException(g);
2200 <    }
2201 <
2202 <    /**
2203 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2204 <     */
2205 <    public void testApplyToEitherAsync4() {
2206 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2207 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2208 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2209 <        assertTrue(f.cancel(true));
2210 <        checkCompletedWithWrappedCancellationException(g);
2211 <
2212 <        f = new CompletableFuture<>();
2213 <        f2 = new CompletableFuture<>();
2214 <        assertTrue(f2.cancel(true));
2215 <        g = f.applyToEitherAsync(f2, inc);
2216 <        checkCompletedWithWrappedCancellationException(g);
2217 <    }
2218 <
2219 <    /**
2220 <     * acceptEitherAsync result completes normally after normal
2221 <     * completion of sources
2222 <     */
2223 <    public void testAcceptEitherAsync() {
2224 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2225 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2226 <        IncAction r = new IncAction();
2227 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2228 <        f.complete(one);
2229 <        checkCompletedNormally(g, null);
2230 <        assertEquals(r.value, 2);
2231 <
2232 <        r = new IncAction();
2233 <        f = new CompletableFuture<>();
2234 <        f.complete(one);
2235 <        f2 = new CompletableFuture<>();
2236 <        g = f.acceptEitherAsync(f2, r);
2237 <        checkCompletedNormally(g, null);
2238 <        assertEquals(r.value, 2);
2239 <    }
2240 <
2241 <    /**
2242 <     * acceptEitherAsync result completes exceptionally after exceptional
2243 <     * completion of source
2244 <     */
2245 <    public void testAcceptEitherAsync2() {
2246 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2247 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2248 <        IncAction r = new IncAction();
2249 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2250 <        f.completeExceptionally(new CFException());
2251 <        checkCompletedWithWrappedCFException(g);
2252 <
2253 <        r = new IncAction();
2254 <        f = new CompletableFuture<>();
2255 <        f2 = new CompletableFuture<>();
2256 <        f2.completeExceptionally(new CFException());
2257 <        g = f.acceptEitherAsync(f2, r);
2258 <        f.complete(one);
2259 <        checkCompletedWithWrappedCFException(g);
2260 <    }
2261 <
2262 <    /**
2263 <     * acceptEitherAsync result completes exceptionally if action does
2264 <     */
2265 <    public void testAcceptEitherAsync3() {
2266 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2267 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2268 <        FailingConsumer r = new FailingConsumer();
2269 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2270 <        f.complete(one);
2271 <        checkCompletedWithWrappedCFException(g);
2272 <    }
2273 <
2274 <    /**
2275 <     * acceptEitherAsync result completes exceptionally if either
2276 <     * source cancelled
2277 <     */
2278 <    public void testAcceptEitherAsync4() {
2279 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2280 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2281 <        IncAction r = new IncAction();
2282 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2283 <        assertTrue(f.cancel(true));
2284 <        checkCompletedWithWrappedCancellationException(g);
2285 <
2286 <        r = new IncAction();
2287 <        f = new CompletableFuture<>();
2288 <        f2 = new CompletableFuture<>();
2289 <        assertTrue(f2.cancel(true));
2290 <        g = f.acceptEitherAsync(f2, r);
2291 <        checkCompletedWithWrappedCancellationException(g);
2292 <    }
2293 <
2294 <    /**
2295 <     * runAfterEitherAsync result completes normally after normal
2296 <     * completion of sources
2297 <     */
2298 <    public void testRunAfterEitherAsync() {
2299 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2300 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2301 <        Noop r = new Noop();
2302 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2303 <        f.complete(one);
2304 <        checkCompletedNormally(g, null);
2305 <        assertTrue(r.ran);
2306 <
2307 <        r = new Noop();
2308 <        f = new CompletableFuture<>();
2309 <        f.complete(one);
2310 <        f2 = new CompletableFuture<>();
2311 <        g = f.runAfterEitherAsync(f2, r);
2312 <        checkCompletedNormally(g, null);
2313 <        assertTrue(r.ran);
2314 <    }
2315 <
2316 <    /**
2317 <     * runAfterEitherAsync result completes exceptionally after exceptional
2318 <     * completion of source
2319 <     */
2320 <    public void testRunAfterEitherAsync2() {
2321 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2322 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2323 <        Noop r = new Noop();
2324 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2325 <        f.completeExceptionally(new CFException());
2326 <        checkCompletedWithWrappedCFException(g);
2327 <
2328 <        r = new Noop();
2329 <        f = new CompletableFuture<>();
2330 <        f2 = new CompletableFuture<>();
2331 <        f2.completeExceptionally(new CFException());
2332 <        g = f.runAfterEitherAsync(f2, r);
2333 <        f.complete(one);
2334 <        checkCompletedWithWrappedCFException(g);
2335 <    }
2336 <
2337 <    /**
2338 <     * runAfterEitherAsync result completes exceptionally if action does
2339 <     */
2340 <    public void testRunAfterEitherAsync3() {
2341 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2342 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2343 <        FailingNoop r = new FailingNoop();
2344 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2345 <        f.complete(one);
2346 <        checkCompletedWithWrappedCFException(g);
2347 <    }
2348 <
2349 <    /**
2350 <     * runAfterEitherAsync result completes exceptionally if either
2351 <     * source cancelled
2352 <     */
2353 <    public void testRunAfterEitherAsync4() {
2354 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2355 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2356 <        Noop r = new Noop();
2357 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2358 <        assertTrue(f.cancel(true));
2359 <        checkCompletedWithWrappedCancellationException(g);
2360 <
2361 <        r = new Noop();
2362 <        f = new CompletableFuture<>();
2363 <        f2 = new CompletableFuture<>();
2364 <        assertTrue(f2.cancel(true));
2365 <        g = f.runAfterEitherAsync(f2, r);
2366 <        checkCompletedWithWrappedCancellationException(g);
2367 <    }
2368 <
2369 <    /**
2370 <     * thenComposeAsync result completes normally after normal
2371 <     * completion of source
2372 <     */
2373 <    public void testThenComposeAsync() {
2374 <        CompletableFuture<Integer> f, g;
2375 <        CompletableFutureInc r;
2376 <
2377 <        f = new CompletableFuture<>();
2378 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2379 <        f.complete(one);
2380 <        checkCompletedNormally(g, two);
2381 <
2382 <        f = new CompletableFuture<>();
2383 <        f.complete(one);
2384 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2385 <        checkCompletedNormally(g, two);
2386 <    }
2387 <
2388 <    /**
2389 <     * thenComposeAsync result completes exceptionally after
2390 <     * exceptional completion of source
2391 <     */
2392 <    public void testThenComposeAsync2() {
2393 <        CompletableFuture<Integer> f, g;
2394 <        CompletableFutureInc r;
2395 <
2396 <        f = new CompletableFuture<>();
2397 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2398 <        f.completeExceptionally(new CFException());
2399 <        checkCompletedWithWrappedCFException(g);
2400 <        assertFalse(r.ran);
2401 <
2402 <        f = new CompletableFuture<>();
2403 <        f.completeExceptionally(new CFException());
2404 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2405 <        checkCompletedWithWrappedCFException(g);
2406 <        assertFalse(r.ran);
2407 <    }
2408 <
2409 <    /**
2410 <     * thenComposeAsync result completes exceptionally if action does
2411 <     */
2412 <    public void testThenComposeAsync3() {
2413 <        CompletableFuture<Integer> f, g;
2414 <        FailingCompletableFutureFunction r;
2415 <
2416 <        f = new CompletableFuture<>();
2417 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2418 <        f.complete(one);
2419 <        checkCompletedWithWrappedCFException(g);
2420 <
2421 <        f = new CompletableFuture<>();
2422 <        f.complete(one);
2423 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2424 <        checkCompletedWithWrappedCFException(g);
2425 <    }
2426 <
2427 <    /**
2428 <     * thenComposeAsync result completes exceptionally if source cancelled
2429 <     */
2430 <    public void testThenComposeAsync4() {
2431 <        CompletableFuture<Integer> f, g;
2432 <        CompletableFutureInc r;
2433 <
2434 <        f = new CompletableFuture<>();
2435 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2436 <        assertTrue(f.cancel(true));
2437 <        checkCompletedWithWrappedCancellationException(g);
2438 <
2439 <        f = new CompletableFuture<>();
2440 <        assertTrue(f.cancel(true));
2441 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2442 <        checkCompletedWithWrappedCancellationException(g);
2443 <    }
2444 <
2445 <    // async with explicit executors
2446 <
2447 <    /**
2448 <     * thenRunAsync result completes normally after normal completion of source
2449 <     */
2450 <    public void testThenRunAsyncE() {
2451 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2452 <        Noop r = new Noop();
2453 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2454 <        f.complete(null);
2455 <        checkCompletedNormally(g, null);
2456 <
2457 <        // reordered version
2458 <        f = new CompletableFuture<>();
2459 <        f.complete(null);
2460 <        r = new Noop();
2461 <        g = f.thenRunAsync(r, new ThreadExecutor());
2462 <        checkCompletedNormally(g, null);
2463 <    }
2464 <
2465 <    /**
2466 <     * thenRunAsync result completes exceptionally after exceptional
2467 <     * completion of source
2468 <     */
2469 <    public void testThenRunAsync2E() {
2470 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2471 <        Noop r = new Noop();
2472 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2473 <        f.completeExceptionally(new CFException());
2474 <        try {
2475 <            g.join();
2476 <            shouldThrow();
2477 <        } catch (CompletionException success) {}
2478 <        checkCompletedWithWrappedCFException(g);
2479 <    }
2480 <
2481 <    /**
2482 <     * thenRunAsync result completes exceptionally if action does
2483 <     */
2484 <    public void testThenRunAsync3E() {
2485 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2486 <        FailingNoop r = new FailingNoop();
2487 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2488 <        f.complete(null);
2489 <        checkCompletedWithWrappedCFException(g);
2490 <    }
2491 <
2492 <    /**
2493 <     * thenRunAsync result completes exceptionally if source cancelled
2494 <     */
2495 <    public void testThenRunAsync4E() {
2496 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2497 <        Noop r = new Noop();
2498 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2499 <        assertTrue(f.cancel(true));
2500 <        checkCompletedWithWrappedCancellationException(g);
2501 <    }
2502 <
2503 <    /**
2504 <     * thenApplyAsync result completes normally after normal completion of source
2505 <     */
2506 <    public void testThenApplyAsyncE() {
2507 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2508 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2509 <        f.complete(one);
2510 <        checkCompletedNormally(g, two);
2511 <    }
2512 <
2513 <    /**
2514 <     * thenApplyAsync result completes exceptionally after exceptional
2515 <     * completion of source
2516 <     */
2517 <    public void testThenApplyAsync2E() {
2518 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2519 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2520 <        f.completeExceptionally(new CFException());
2521 <        checkCompletedWithWrappedCFException(g);
2522 <    }
2523 <
2524 <    /**
2525 <     * thenApplyAsync result completes exceptionally if action does
2526 <     */
2527 <    public void testThenApplyAsync3E() {
2528 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2529 <        FailingFunction r = new FailingFunction();
2530 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2531 <        f.complete(null);
2532 <        checkCompletedWithWrappedCFException(g);
2533 <    }
2534 <
2535 <    /**
2536 <     * thenApplyAsync result completes exceptionally if source cancelled
2537 <     */
2538 <    public void testThenApplyAsync4E() {
2539 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2540 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2541 <        assertTrue(f.cancel(true));
2542 <        checkCompletedWithWrappedCancellationException(g);
2543 <    }
2544 <
2545 <    /**
2546 <     * thenAcceptAsync result completes normally after normal
2547 <     * completion of source
2548 <     */
2549 <    public void testThenAcceptAsyncE() {
2550 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2551 <        IncAction r = new IncAction();
2552 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2553 <        f.complete(one);
2554 <        checkCompletedNormally(g, null);
2555 <        assertEquals(r.value, 2);
2556 <    }
2557 <
2558 <    /**
2559 <     * thenAcceptAsync result completes exceptionally after exceptional
2560 <     * completion of source
2561 <     */
2562 <    public void testThenAcceptAsync2E() {
2563 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2564 <        IncAction r = new IncAction();
2565 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2566 <        f.completeExceptionally(new CFException());
2567 <        checkCompletedWithWrappedCFException(g);
2568 <    }
2569 <
2570 <    /**
2571 <     * thenAcceptAsync result completes exceptionally if action does
2572 <     */
2573 <    public void testThenAcceptAsync3E() {
2574 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2575 <        FailingConsumer r = new FailingConsumer();
2576 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2577 <        f.complete(null);
2578 <        checkCompletedWithWrappedCFException(g);
2579 <    }
2580 <
2581 <    /**
2582 <     * thenAcceptAsync result completes exceptionally if source cancelled
2583 <     */
2584 <    public void testThenAcceptAsync4E() {
2585 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2586 <        IncAction r = new IncAction();
2587 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2588 <        assertTrue(f.cancel(true));
2589 <        checkCompletedWithWrappedCancellationException(g);
2590 <    }
2591 <
2592 <    /**
2593 <     * applyToEitherAsync result completes normally after normal
2594 <     * completion of sources
2595 <     */
2596 <    public void testApplyToEitherAsyncE() {
2597 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2598 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2599 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2600 <        f.complete(one);
2601 <        checkCompletedNormally(g, two);
2602 <
2603 <        f = new CompletableFuture<>();
2604 <        f.complete(one);
2605 <        f2 = new CompletableFuture<>();
2606 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2607 <        checkCompletedNormally(g, two);
2608 <    }
2609 <
2610 <    /**
2611 <     * applyToEitherAsync result completes exceptionally after exceptional
2612 <     * completion of source
2613 <     */
2614 <    public void testApplyToEitherAsync2E() {
2615 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2616 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2617 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2618 <        f.completeExceptionally(new CFException());
2619 <        checkCompletedWithWrappedCFException(g);
2620 <
2621 <        f = new CompletableFuture<>();
2622 <        f2 = new CompletableFuture<>();
2623 <        f2.completeExceptionally(new CFException());
2624 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2625 <        f.complete(one);
2626 <        checkCompletedWithWrappedCFException(g);
2627 <    }
2628 <
2629 <    /**
2630 <     * applyToEitherAsync result completes exceptionally if action does
2631 <     */
2632 <    public void testApplyToEitherAsync3E() {
2633 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2634 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2635 <        FailingFunction r = new FailingFunction();
2636 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
2637 <        f.complete(one);
2638 <        checkCompletedWithWrappedCFException(g);
2639 <    }
2640 <
2641 <    /**
2642 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2643 <     */
2644 <    public void testApplyToEitherAsync4E() {
2645 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2646 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2647 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2648 <        assertTrue(f.cancel(true));
2649 <        checkCompletedWithWrappedCancellationException(g);
2650 <
2651 <        f = new CompletableFuture<>();
2652 <        f2 = new CompletableFuture<>();
2653 <        assertTrue(f2.cancel(true));
2654 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2655 <        checkCompletedWithWrappedCancellationException(g);
2656 <    }
2657 <
2658 <    /**
2659 <     * acceptEitherAsync result completes normally after normal
2660 <     * completion of sources
2661 <     */
2662 <    public void testAcceptEitherAsyncE() {
2663 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2664 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2665 <        IncAction r = new IncAction();
2666 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2667 <        f.complete(one);
2668 <        checkCompletedNormally(g, null);
2669 <        assertEquals(r.value, 2);
2670 <
2671 <        r = new IncAction();
2672 <        f = new CompletableFuture<>();
2673 <        f.complete(one);
2674 <        f2 = new CompletableFuture<>();
2675 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2676 <        checkCompletedNormally(g, null);
2677 <        assertEquals(r.value, 2);
2678 <    }
2679 <
2680 <    /**
2681 <     * acceptEitherAsync result completes exceptionally after exceptional
2682 <     * completion of source
2683 <     */
2684 <    public void testAcceptEitherAsync2E() {
2685 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2686 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2687 <        IncAction r = new IncAction();
2688 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2689 <        f.completeExceptionally(new CFException());
2690 <        checkCompletedWithWrappedCFException(g);
2691 <
2692 <        r = new IncAction();
2693 <        f = new CompletableFuture<>();
2694 <        f2 = new CompletableFuture<>();
2695 <        f2.completeExceptionally(new CFException());
2696 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2697 <        f.complete(one);
2698 <        checkCompletedWithWrappedCFException(g);
2699 <    }
2700 <
2701 <    /**
2702 <     * acceptEitherAsync result completes exceptionally if action does
2703 <     */
2704 <    public void testAcceptEitherAsync3E() {
2705 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2706 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2707 <        FailingConsumer r = new FailingConsumer();
2708 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2709 <        f.complete(one);
2710 <        checkCompletedWithWrappedCFException(g);
2711 <    }
2712 <
2713 <    /**
2714 <     * acceptEitherAsync result completes exceptionally if either
2715 <     * source cancelled
2716 <     */
2717 <    public void testAcceptEitherAsync4E() {
2718 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2719 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2720 <        IncAction r = new IncAction();
2721 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2722 <        assertTrue(f.cancel(true));
2723 <        checkCompletedWithWrappedCancellationException(g);
2724 <
2725 <        r = new IncAction();
2726 <        f = new CompletableFuture<>();
2727 <        f2 = new CompletableFuture<>();
2728 <        assertTrue(f2.cancel(true));
2729 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2730 <        checkCompletedWithWrappedCancellationException(g);
2731 <    }
2732 <
2733 <    /**
2734 <     * runAfterEitherAsync result completes normally after normal
2735 <     * completion of sources
2736 <     */
2737 <    public void testRunAfterEitherAsyncE() {
2738 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2739 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2740 <        Noop r = new Noop();
2741 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2742 <        f.complete(one);
2743 <        checkCompletedNormally(g, null);
2744 <        assertTrue(r.ran);
2745 <
2746 <        r = new Noop();
2747 <        f = new CompletableFuture<>();
2748 <        f.complete(one);
2749 <        f2 = new CompletableFuture<>();
2750 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2751 <        checkCompletedNormally(g, null);
2752 <        assertTrue(r.ran);
2753 <    }
2754 <
2755 <    /**
2756 <     * runAfterEitherAsync result completes exceptionally after exceptional
2757 <     * completion of source
2758 <     */
2759 <    public void testRunAfterEitherAsync2E() {
2760 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2761 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2762 <        Noop r = new Noop();
2763 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2764 <        f.completeExceptionally(new CFException());
2765 <        checkCompletedWithWrappedCFException(g);
2766 <
2767 <        r = new Noop();
2768 <        f = new CompletableFuture<>();
2769 <        f2 = new CompletableFuture<>();
2770 <        f2.completeExceptionally(new CFException());
2771 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2772 <        f.complete(one);
2773 <        checkCompletedWithWrappedCFException(g);
2774 <    }
2775 <
2776 <    /**
2777 <     * runAfterEitherAsync result completes exceptionally if action does
2778 <     */
2779 <    public void testRunAfterEitherAsync3E() {
2780 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2781 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2782 <        FailingNoop r = new FailingNoop();
2783 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2784 <        f.complete(one);
2785 <        checkCompletedWithWrappedCFException(g);
2786 <    }
2787 <
2788 <    /**
2789 <     * runAfterEitherAsync result completes exceptionally if either
2790 <     * source cancelled
2791 <     */
2792 <    public void testRunAfterEitherAsync4E() {
2793 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2794 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2795 <        Noop r = new Noop();
2796 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2797 <        assertTrue(f.cancel(true));
2798 <        checkCompletedWithWrappedCancellationException(g);
2799 <
2800 <        r = new Noop();
2801 <        f = new CompletableFuture<>();
2802 <        f2 = new CompletableFuture<>();
2803 <        assertTrue(f2.cancel(true));
2804 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2805 <        checkCompletedWithWrappedCancellationException(g);
2806 <    }
2807 <
2808 <    /**
2809 <     * thenComposeAsync result completes normally after normal
2810 <     * completion of source
2811 <     */
2812 <    public void testThenComposeAsyncE() {
2813 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2814 <        CompletableFutureInc r = new CompletableFutureInc();
2815 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2816 <        f.complete(one);
2817 <        checkCompletedNormally(g, two);
2818 <    }
2819 <
2820 <    /**
2821 <     * thenComposeAsync result completes exceptionally after
2822 <     * exceptional completion of source
2823 <     */
2824 <    public void testThenComposeAsync2E() {
2825 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2826 <        CompletableFutureInc r = new CompletableFutureInc();
2827 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2828 <        f.completeExceptionally(new CFException());
2829 <        checkCompletedWithWrappedCFException(g);
2830 <    }
2831 <
2832 <    /**
2833 <     * thenComposeAsync result completes exceptionally if action does
2834 <     */
2835 <    public void testThenComposeAsync3E() {
2836 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2837 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2838 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2839 <        f.complete(one);
2840 <        checkCompletedWithWrappedCFException(g);
2841 <    }
2465 >    public void testThenCompose_sourceCancelled() {
2466 >        for (ExecutionMode m : ExecutionMode.values())
2467 >        for (boolean createIncomplete : new boolean[] { true, false })
2468 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2469 >    {
2470 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2471 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2472 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2473 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2474 >        if (createIncomplete) {
2475 >            checkIncomplete(g);
2476 >            assertTrue(f.cancel(mayInterruptIfRunning));
2477 >        }
2478  
2843    /**
2844     * thenComposeAsync result completes exceptionally if source cancelled
2845     */
2846    public void testThenComposeAsync4E() {
2847        CompletableFuture<Integer> f = new CompletableFuture<>();
2848        CompletableFutureInc r = new CompletableFutureInc();
2849        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2850        assertTrue(f.cancel(true));
2479          checkCompletedWithWrappedCancellationException(g);
2480 <    }
2480 >        checkCancelled(f);
2481 >    }}
2482  
2483      // other static methods
2484  
# Line 2868 | Line 2497 | public class CompletableFutureTest exten
2497       */
2498      public void testAllOf_normal() throws Exception {
2499          for (int k = 1; k < 20; ++k) {
2500 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2500 >            CompletableFuture<Integer>[] fs
2501 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2502              for (int i = 0; i < k; ++i)
2503                  fs[i] = new CompletableFuture<>();
2504              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
# Line 2882 | Line 2512 | public class CompletableFutureTest exten
2512          }
2513      }
2514  
2515 +    public void testAllOf_backwards() throws Exception {
2516 +        for (int k = 1; k < 20; ++k) {
2517 +            CompletableFuture<Integer>[] fs
2518 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2519 +            for (int i = 0; i < k; ++i)
2520 +                fs[i] = new CompletableFuture<>();
2521 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2522 +            for (int i = k - 1; i >= 0; i--) {
2523 +                checkIncomplete(f);
2524 +                checkIncomplete(CompletableFuture.allOf(fs));
2525 +                fs[i].complete(one);
2526 +            }
2527 +            checkCompletedNormally(f, null);
2528 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
2529 +        }
2530 +    }
2531 +
2532      /**
2533       * anyOf(no component futures) returns an incomplete future
2534       */
# Line 2940 | Line 2587 | public class CompletableFutureTest exten
2587          Runnable[] throwingActions = {
2588              () -> CompletableFuture.supplyAsync(null),
2589              () -> CompletableFuture.supplyAsync(null, exec),
2590 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
2590 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
2591  
2592              () -> CompletableFuture.runAsync(null),
2593              () -> CompletableFuture.runAsync(null, exec),
# Line 3013 | Line 2660 | public class CompletableFutureTest exten
2660  
2661              () -> f.thenCompose(null),
2662              () -> f.thenComposeAsync(null),
2663 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2663 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2664              () -> f.thenComposeAsync(null, exec),
2665  
2666              () -> f.exceptionally(null),
# Line 3049 | Line 2696 | public class CompletableFutureTest exten
2696       * whenComplete action executes on normal completion, propagating
2697       * source result.
2698       */
2699 <    public void testWhenComplete1() {
2700 <        final AtomicInteger a = new AtomicInteger();
2701 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2702 <        CompletableFuture<Integer> g =
2703 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
2704 <        f.complete(three);
2705 <        checkCompletedNormally(f, three);
2706 <        checkCompletedNormally(g, three);
2707 <        assertEquals(a.get(), 1);
2708 <    }
2709 <
2710 <    /**
2711 <     * whenComplete action executes on exceptional completion, propagating
2712 <     * source result.
2713 <     */
2714 <    public void testWhenComplete2() {
3068 <        final AtomicInteger a = new AtomicInteger();
3069 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3070 <        CompletableFuture<Integer> g =
3071 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3072 <        f.completeExceptionally(new CFException());
3073 <        assertTrue(f.isCompletedExceptionally());
3074 <        assertTrue(g.isCompletedExceptionally());
3075 <        assertEquals(a.get(), 1);
3076 <    }
3077 <
3078 <    /**
3079 <     * If a whenComplete action throws an exception when triggered by
3080 <     * a normal completion, it completes exceptionally
3081 <     */
3082 <    public void testWhenComplete3() {
3083 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3084 <        CompletableFuture<Integer> g =
3085 <            f.whenComplete((Integer x, Throwable t) ->
3086 <                           { throw new CFException(); } );
3087 <        f.complete(three);
3088 <        checkCompletedNormally(f, three);
3089 <        assertTrue(g.isCompletedExceptionally());
3090 <        checkCompletedWithWrappedCFException(g);
3091 <    }
3092 <
3093 <    /**
3094 <     * whenCompleteAsync action executes on normal completion, propagating
3095 <     * source result.
3096 <     */
3097 <    public void testWhenCompleteAsync1() {
3098 <        final AtomicInteger a = new AtomicInteger();
3099 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3100 <        CompletableFuture<Integer> g =
3101 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3102 <        f.complete(three);
3103 <        checkCompletedNormally(f, three);
3104 <        checkCompletedNormally(g, three);
3105 <        assertEquals(a.get(), 1);
3106 <    }
3107 <
3108 <    /**
3109 <     * whenCompleteAsync action executes on exceptional completion, propagating
3110 <     * source result.
3111 <     */
3112 <    public void testWhenCompleteAsync2() {
3113 <        final AtomicInteger a = new AtomicInteger();
3114 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3115 <        CompletableFuture<Integer> g =
3116 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3117 <        f.completeExceptionally(new CFException());
3118 <        checkCompletedWithWrappedCFException(f);
3119 <        checkCompletedWithWrappedCFException(g);
3120 <    }
2699 >    public void testWhenComplete_normalCompletion1() {
2700 >        for (ExecutionMode m : ExecutionMode.values())
2701 >        for (boolean createIncomplete : new boolean[] { true, false })
2702 >        for (Integer v1 : new Integer[] { 1, null })
2703 >    {
2704 >        final AtomicInteger a = new AtomicInteger(0);
2705 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2706 >        if (!createIncomplete) f.complete(v1);
2707 >        final CompletableFuture<Integer> g = m.whenComplete
2708 >            (f,
2709 >             (Integer x, Throwable t) -> {
2710 >                threadAssertSame(x, v1);
2711 >                threadAssertNull(t);
2712 >                a.getAndIncrement();
2713 >            });
2714 >        if (createIncomplete) f.complete(v1);
2715  
2716 <    /**
2717 <     * If a whenCompleteAsync action throws an exception when
2718 <     * triggered by a normal completion, it completes exceptionally
2719 <     */
3126 <    public void testWhenCompleteAsync3() {
3127 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3128 <        CompletableFuture<Integer> g =
3129 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3130 <                           { throw new CFException(); } );
3131 <        f.complete(three);
3132 <        checkCompletedNormally(f, three);
3133 <        checkCompletedWithWrappedCFException(g);
3134 <    }
2716 >        checkCompletedNormally(g, v1);
2717 >        checkCompletedNormally(f, v1);
2718 >        assertEquals(1, a.get());
2719 >    }}
2720  
2721      /**
2722 <     * whenCompleteAsync action executes on normal completion, propagating
2722 >     * whenComplete action executes on exceptional completion, propagating
2723       * source result.
2724       */
2725 <    public void testWhenCompleteAsync1e() {
2726 <        final AtomicInteger a = new AtomicInteger();
2727 <        ThreadExecutor exec = new ThreadExecutor();
2728 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2729 <        CompletableFuture<Integer> g =
2730 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
2731 <                                exec);
2732 <        f.complete(three);
2733 <        checkCompletedNormally(f, three);
2734 <        checkCompletedNormally(g, three);
2735 <        assertEquals(a.get(), 1);
2736 <    }
2725 >    public void testWhenComplete_exceptionalCompletion() {
2726 >        for (ExecutionMode m : ExecutionMode.values())
2727 >        for (boolean createIncomplete : new boolean[] { true, false })
2728 >        for (Integer v1 : new Integer[] { 1, null })
2729 >    {
2730 >        final AtomicInteger a = new AtomicInteger(0);
2731 >        final CFException ex = new CFException();
2732 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2733 >        if (!createIncomplete) f.completeExceptionally(ex);
2734 >        final CompletableFuture<Integer> g = m.whenComplete
2735 >            (f,
2736 >             (Integer x, Throwable t) -> {
2737 >                threadAssertNull(x);
2738 >                threadAssertSame(t, ex);
2739 >                a.getAndIncrement();
2740 >            });
2741 >        if (createIncomplete) f.completeExceptionally(ex);
2742 >        checkCompletedWithWrappedCFException(f, ex);
2743 >        checkCompletedWithWrappedCFException(g, ex);
2744 >        assertEquals(1, a.get());
2745 >    }}
2746  
2747      /**
2748 <     * whenCompleteAsync action executes on exceptional completion, propagating
2749 <     * source result.
2748 >     * whenComplete action executes on cancelled source, propagating
2749 >     * CancellationException.
2750       */
2751 <    public void testWhenCompleteAsync2e() {
2752 <        final AtomicInteger a = new AtomicInteger();
2753 <        ThreadExecutor exec = new ThreadExecutor();
2754 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2755 <        CompletableFuture<Integer> g =
2756 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
2757 <                                exec);
2758 <        f.completeExceptionally(new CFException());
2759 <        checkCompletedWithWrappedCFException(f);
2760 <        checkCompletedWithWrappedCFException(g);
2761 <    }
2751 >    public void testWhenComplete_sourceCancelled() {
2752 >        for (ExecutionMode m : ExecutionMode.values())
2753 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2754 >        for (boolean createIncomplete : new boolean[] { true, false })
2755 >    {
2756 >        final AtomicInteger a = new AtomicInteger(0);
2757 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2758 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2759 >        final CompletableFuture<Integer> g = m.whenComplete
2760 >            (f,
2761 >             (Integer x, Throwable t) -> {
2762 >                threadAssertNull(x);
2763 >                threadAssertTrue(t instanceof CancellationException);
2764 >                a.getAndIncrement();
2765 >            });
2766 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2767  
2768 <    /**
2769 <     * If a whenCompleteAsync action throws an exception when triggered
2770 <     * by a normal completion, it completes exceptionally
2771 <     */
2772 <    public void testWhenCompleteAsync3e() {
3174 <        ThreadExecutor exec = new ThreadExecutor();
3175 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3176 <        CompletableFuture<Integer> g =
3177 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3178 <                                { throw new CFException(); },
3179 <                                exec);
3180 <        f.complete(three);
3181 <        checkCompletedNormally(f, three);
3182 <        checkCompletedWithWrappedCFException(g);
3183 <    }
2768 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
2769 >        checkCompletedWithWrappedCancellationException(g);
2770 >        checkCancelled(f);
2771 >        assertEquals(1, a.get());
2772 >    }}
2773  
2774      /**
2775 <     * handleAsync action completes normally with function value on
2776 <     * either normal or exceptional completion of source
2775 >     * If a whenComplete action throws an exception when triggered by
2776 >     * a normal completion, it completes exceptionally
2777       */
2778 <    public void testHandleAsync() {
2779 <        CompletableFuture<Integer> f, g;
2780 <        IntegerHandler r;
2781 <
2782 <        f = new CompletableFuture<>();
2783 <        g = f.handleAsync(r = new IntegerHandler());
2784 <        assertFalse(r.ran);
2785 <        f.completeExceptionally(new CFException());
2786 <        checkCompletedWithWrappedCFException(f);
2787 <        checkCompletedNormally(g, three);
2788 <        assertTrue(r.ran);
2789 <
2790 <        f = new CompletableFuture<>();
2791 <        g = f.handleAsync(r = new IntegerHandler());
2792 <        assertFalse(r.ran);
2793 <        f.completeExceptionally(new CFException());
2794 <        checkCompletedWithWrappedCFException(f);
2795 <        checkCompletedNormally(g, three);
2796 <        assertTrue(r.ran);
2797 <
2798 <        f = new CompletableFuture<>();
2799 <        g = f.handleAsync(r = new IntegerHandler());
3211 <        assertFalse(r.ran);
3212 <        f.complete(one);
3213 <        checkCompletedNormally(f, one);
3214 <        checkCompletedNormally(g, two);
3215 <        assertTrue(r.ran);
3216 <
3217 <        f = new CompletableFuture<>();
3218 <        g = f.handleAsync(r = new IntegerHandler());
3219 <        assertFalse(r.ran);
3220 <        f.complete(one);
3221 <        checkCompletedNormally(f, one);
3222 <        checkCompletedNormally(g, two);
3223 <        assertTrue(r.ran);
3224 <    }
2778 >    public void testWhenComplete_actionFailed() {
2779 >        for (boolean createIncomplete : new boolean[] { true, false })
2780 >        for (ExecutionMode m : ExecutionMode.values())
2781 >        for (Integer v1 : new Integer[] { 1, null })
2782 >    {
2783 >        final AtomicInteger a = new AtomicInteger(0);
2784 >        final CFException ex = new CFException();
2785 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2786 >        if (!createIncomplete) f.complete(v1);
2787 >        final CompletableFuture<Integer> g = m.whenComplete
2788 >            (f,
2789 >             (Integer x, Throwable t) -> {
2790 >                threadAssertSame(x, v1);
2791 >                threadAssertNull(t);
2792 >                a.getAndIncrement();
2793 >                throw ex;
2794 >            });
2795 >        if (createIncomplete) f.complete(v1);
2796 >        checkCompletedNormally(f, v1);
2797 >        checkCompletedWithWrappedCFException(g, ex);
2798 >        assertEquals(1, a.get());
2799 >    }}
2800  
2801      /**
2802 <     * handleAsync action with Executor completes normally with
2803 <     * function value on either normal or exceptional completion of
2804 <     * source
2802 >     * If a whenComplete action throws an exception when triggered by
2803 >     * a source completion that also throws an exception, the source
2804 >     * exception takes precedence.
2805       */
2806 <    public void testHandleAsync2() {
2807 <        CompletableFuture<Integer> f, g;
2808 <        ThreadExecutor exec = new ThreadExecutor();
2809 <        IntegerHandler r;
2810 <
2811 <        f = new CompletableFuture<>();
2812 <        g = f.handleAsync(r = new IntegerHandler(), exec);
2813 <        assertFalse(r.ran);
2814 <        f.completeExceptionally(new CFException());
2815 <        checkCompletedWithWrappedCFException(f);
2816 <        checkCompletedNormally(g, three);
2817 <        assertTrue(r.ran);
2818 <
2819 <        f = new CompletableFuture<>();
2820 <        g = f.handleAsync(r = new IntegerHandler(), exec);
2821 <        assertFalse(r.ran);
2822 <        f.completeExceptionally(new CFException());
2823 <        checkCompletedWithWrappedCFException(f);
2824 <        checkCompletedNormally(g, three);
2825 <        assertTrue(r.ran);
2826 <
2827 <        f = new CompletableFuture<>();
2828 <        g = f.handleAsync(r = new IntegerHandler(), exec);
2829 <        assertFalse(r.ran);
2830 <        f.complete(one);
3256 <        checkCompletedNormally(f, one);
3257 <        checkCompletedNormally(g, two);
3258 <        assertTrue(r.ran);
3259 <
3260 <        f = new CompletableFuture<>();
3261 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3262 <        assertFalse(r.ran);
3263 <        f.complete(one);
3264 <        checkCompletedNormally(f, one);
3265 <        checkCompletedNormally(g, two);
3266 <        assertTrue(r.ran);
3267 <    }
2806 >    public void testWhenComplete_actionFailedSourceFailed() {
2807 >        for (boolean createIncomplete : new boolean[] { true, false })
2808 >        for (ExecutionMode m : ExecutionMode.values())
2809 >        for (Integer v1 : new Integer[] { 1, null })
2810 >    {
2811 >        final AtomicInteger a = new AtomicInteger(0);
2812 >        final CFException ex1 = new CFException();
2813 >        final CFException ex2 = new CFException();
2814 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2815 >
2816 >        if (!createIncomplete) f.completeExceptionally(ex1);
2817 >        final CompletableFuture<Integer> g = m.whenComplete
2818 >            (f,
2819 >             (Integer x, Throwable t) -> {
2820 >                threadAssertSame(t, ex1);
2821 >                threadAssertNull(x);
2822 >                a.getAndIncrement();
2823 >                throw ex2;
2824 >            });
2825 >        if (createIncomplete) f.completeExceptionally(ex1);
2826 >
2827 >        checkCompletedWithWrappedCFException(f, ex1);
2828 >        checkCompletedWithWrappedCFException(g, ex1);
2829 >        assertEquals(1, a.get());
2830 >    }}
2831  
2832   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines