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.44 by jsr166, Mon Jun 2 06:06:30 2014 UTC vs.
Revision 1.53 by jsr166, Mon Jun 2 20:20:47 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);
286 >        assertEquals(0, f.getNumberOfDependents());
287          CompletableFuture g = f.thenRun(new Noop());
288 <        assertEquals(f.getNumberOfDependents(), 1);
289 <        assertEquals(g.getNumberOfDependents(), 0);
288 >        assertEquals(1, f.getNumberOfDependents());
289 >        assertEquals(0, g.getNumberOfDependents());
290          CompletableFuture h = f.thenRun(new Noop());
291 <        assertEquals(f.getNumberOfDependents(), 2);
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 412 | Line 416 | public class CompletableFutureTest exten
416              throw new CFException();
417          }
418      }
419 <    static final class FailingNoop implements Runnable {
419 >    static final class FailingRunnable implements Runnable {
420          int invocationCount = 0;
421          public void run() {
422              invocationCount++;
# Line 450 | Line 454 | public class CompletableFutureTest exten
454          }
455      }
456  
453 –    static final class ExceptionToInteger implements Function<Throwable, Integer> {
454 –        public Integer apply(Throwable x) { return Integer.valueOf(3); }
455 –    }
456 –
457 –    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
458 –        int invocationCount = 0;
459 –        public Integer apply(Integer x, Throwable t) {
460 –            invocationCount++;
461 –            return (t == null) ? two : three;
462 –        }
463 –    }
464 –
457      /**
458       * Permits the testing of parallel code for the 3 different
459       * execution modes without repeating all the testing code.
460       */
461      enum ExecutionMode {
462          DEFAULT {
463 +            public void checkExecutionMode() {
464 +                assertNull(ForkJoinTask.getPool());
465 +            }
466 +            public <T> CompletableFuture<Void> thenRun
467 +                (CompletableFuture<T> f, Runnable a) {
468 +                return f.thenRun(a);
469 +            }
470 +            public <T> CompletableFuture<Void> thenAccept
471 +                (CompletableFuture<T> f, Consumer<? super T> a) {
472 +                return f.thenAccept(a);
473 +            }
474 +            public <T,U> CompletableFuture<U> thenApply
475 +                (CompletableFuture<T> f, Function<? super T,U> a) {
476 +                return f.thenApply(a);
477 +            }
478 +            public <T,U> CompletableFuture<U> thenCompose
479 +                (CompletableFuture<T> f,
480 +                 Function<? super T,? extends CompletionStage<U>> a) {
481 +                return f.thenCompose(a);
482 +            }
483 +            public <T,U> CompletableFuture<U> handle
484 +                (CompletableFuture<T> f,
485 +                 BiFunction<? super T,Throwable,? extends U> a) {
486 +                return f.handle(a);
487 +            }
488 +            public <T> CompletableFuture<T> whenComplete
489 +                (CompletableFuture<T> f,
490 +                 BiConsumer<? super T,? super Throwable> a) {
491 +                return f.whenComplete(a);
492 +            }
493              public <T,U> CompletableFuture<Void> runAfterBoth
494                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
495                  return f.runAfterBoth(g, a);
# Line 484 | Line 506 | public class CompletableFutureTest exten
506                   BiFunction<? super T,? super U,? extends V> a) {
507                  return f.thenCombine(g, a);
508              }
509 <            public <T,U> CompletableFuture<U> applyToEither
509 >            public <T> CompletableFuture<Void> runAfterEither
510                  (CompletableFuture<T> f,
511 <                 CompletionStage<? extends T> g,
512 <                 Function<? super T,U> a) {
513 <                return f.applyToEither(g, a);
511 >                 CompletionStage<?> g,
512 >                 java.lang.Runnable a) {
513 >                return f.runAfterEither(g, a);
514              }
515              public <T> CompletableFuture<Void> acceptEither
516                  (CompletableFuture<T> f,
# Line 496 | Line 518 | public class CompletableFutureTest exten
518                   Consumer<? super T> a) {
519                  return f.acceptEither(g, a);
520              }
521 <            public <T> CompletableFuture<Void> runAfterEither
521 >            public <T,U> CompletableFuture<U> applyToEither
522                  (CompletableFuture<T> f,
523 <                 CompletionStage<?> g,
524 <                 java.lang.Runnable a) {
525 <                return f.runAfterEither(g, a);
523 >                 CompletionStage<? extends T> g,
524 >                 Function<? super T,U> a) {
525 >                return f.applyToEither(g, a);
526 >            }
527 >        },
528 >
529 >        ASYNC {
530 >            public void checkExecutionMode() {
531 >                assertSame(ForkJoinPool.commonPool(),
532 >                           ForkJoinTask.getPool());
533 >            }
534 >            public <T> CompletableFuture<Void> thenRun
535 >                (CompletableFuture<T> f, Runnable a) {
536 >                return f.thenRunAsync(a);
537 >            }
538 >            public <T> CompletableFuture<Void> thenAccept
539 >                (CompletableFuture<T> f, Consumer<? super T> a) {
540 >                return f.thenAcceptAsync(a);
541 >            }
542 >            public <T,U> CompletableFuture<U> thenApply
543 >                (CompletableFuture<T> f, Function<? super T,U> a) {
544 >                return f.thenApplyAsync(a);
545              }
546              public <T,U> CompletableFuture<U> thenCompose
547                  (CompletableFuture<T> f,
548                   Function<? super T,? extends CompletionStage<U>> a) {
549 <                return f.thenCompose(a);
549 >                return f.thenComposeAsync(a);
550 >            }
551 >            public <T,U> CompletableFuture<U> handle
552 >                (CompletableFuture<T> f,
553 >                 BiFunction<? super T,Throwable,? extends U> a) {
554 >                return f.handleAsync(a);
555              }
556              public <T> CompletableFuture<T> whenComplete
557                  (CompletableFuture<T> f,
558                   BiConsumer<? super T,? super Throwable> a) {
559 <                return f.whenComplete(a);
559 >                return f.whenCompleteAsync(a);
560              }
515 –        },
516 –
517 – //             /** Experimental way to do more testing */
518 – //         REVERSE_DEFAULT {
519 – //             public <T,U> CompletableFuture<Void> runAfterBoth
520 – //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
521 – //                 return g.runAfterBoth(f, a);
522 – //             }
523 – //             public <T,U> CompletableFuture<Void> thenAcceptBoth
524 – //                 (CompletableFuture<T> f,
525 – //                  CompletionStage<? extends U> g,
526 – //                  BiConsumer<? super T,? super U> a) {
527 – //                 return DEFAULT.thenAcceptBoth(f, g, a);
528 – //             }
529 – //         },
530 –
531 –        DEFAULT_ASYNC {
561              public <T,U> CompletableFuture<Void> runAfterBoth
562                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
563                  return f.runAfterBothAsync(g, a);
# Line 545 | Line 574 | public class CompletableFutureTest exten
574                   BiFunction<? super T,? super U,? extends V> a) {
575                  return f.thenCombineAsync(g, a);
576              }
577 <            public <T,U> CompletableFuture<U> applyToEither
577 >            public <T> CompletableFuture<Void> runAfterEither
578                  (CompletableFuture<T> f,
579 <                 CompletionStage<? extends T> g,
580 <                 Function<? super T,U> a) {
581 <                return f.applyToEitherAsync(g, a);
579 >                 CompletionStage<?> g,
580 >                 java.lang.Runnable a) {
581 >                return f.runAfterEitherAsync(g, a);
582              }
583              public <T> CompletableFuture<Void> acceptEither
584                  (CompletableFuture<T> f,
# Line 557 | Line 586 | public class CompletableFutureTest exten
586                   Consumer<? super T> a) {
587                  return f.acceptEitherAsync(g, a);
588              }
589 <            public <T> CompletableFuture<Void> runAfterEither
589 >            public <T,U> CompletableFuture<U> applyToEither
590                  (CompletableFuture<T> f,
591 <                 CompletionStage<?> g,
592 <                 java.lang.Runnable a) {
593 <                return f.runAfterEitherAsync(g, a);
591 >                 CompletionStage<? extends T> g,
592 >                 Function<? super T,U> a) {
593 >                return f.applyToEitherAsync(g, a);
594 >            }
595 >        },
596 >
597 >        EXECUTOR {
598 >            public void checkExecutionMode() {
599 >                //TODO
600 >            }
601 >            public <T> CompletableFuture<Void> thenRun
602 >                (CompletableFuture<T> f, Runnable a) {
603 >                return f.thenRunAsync(a, new ThreadExecutor());
604 >            }
605 >            public <T> CompletableFuture<Void> thenAccept
606 >                (CompletableFuture<T> f, Consumer<? super T> a) {
607 >                return f.thenAcceptAsync(a, new ThreadExecutor());
608 >            }
609 >            public <T,U> CompletableFuture<U> thenApply
610 >                (CompletableFuture<T> f, Function<? super T,U> a) {
611 >                return f.thenApplyAsync(a, new ThreadExecutor());
612              }
613              public <T,U> CompletableFuture<U> thenCompose
614                  (CompletableFuture<T> f,
615                   Function<? super T,? extends CompletionStage<U>> a) {
616 <                return f.thenComposeAsync(a);
616 >                return f.thenComposeAsync(a, new ThreadExecutor());
617 >            }
618 >            public <T,U> CompletableFuture<U> handle
619 >                (CompletableFuture<T> f,
620 >                 BiFunction<? super T,Throwable,? extends U> a) {
621 >                return f.handleAsync(a, new ThreadExecutor());
622              }
623              public <T> CompletableFuture<T> whenComplete
624                  (CompletableFuture<T> f,
625                   BiConsumer<? super T,? super Throwable> a) {
626 <                return f.whenCompleteAsync(a);
626 >                return f.whenCompleteAsync(a, new ThreadExecutor());
627              }
576 –        },
577 –
578 – //         REVERSE_DEFAULT_ASYNC {
579 – //             public <T,U> CompletableFuture<Void> runAfterBoth
580 – //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
581 – //                 return f.runAfterBothAsync(g, a);
582 – //             }
583 – //             public <T,U> CompletableFuture<Void> thenAcceptBoth
584 – //                 (CompletableFuture<T> f,
585 – //                  CompletionStage<? extends U> g,
586 – //                  BiConsumer<? super T,? super U> a) {
587 – //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
588 – //             }
589 – //         },
590 –
591 –        EXECUTOR {
628              public <T,U> CompletableFuture<Void> runAfterBoth
629                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
630                  return f.runAfterBothAsync(g, a, new ThreadExecutor());
# Line 605 | Line 641 | public class CompletableFutureTest exten
641                   BiFunction<? super T,? super U,? extends V> a) {
642                  return f.thenCombineAsync(g, a, new ThreadExecutor());
643              }
608 –            public <T,U> CompletableFuture<U> applyToEither
609 –                (CompletableFuture<T> f,
610 –                 CompletionStage<? extends T> g,
611 –                 Function<? super T,U> a) {
612 –                return f.applyToEitherAsync(g, a, new ThreadExecutor());
613 –            }
614 –            public <T> CompletableFuture<Void> acceptEither
615 –                (CompletableFuture<T> f,
616 –                 CompletionStage<? extends T> g,
617 –                 Consumer<? super T> a) {
618 –                return f.acceptEitherAsync(g, a, new ThreadExecutor());
619 –            }
644              public <T> CompletableFuture<Void> runAfterEither
645                  (CompletableFuture<T> f,
646                   CompletionStage<?> g,
647                   java.lang.Runnable a) {
648                  return f.runAfterEitherAsync(g, a, new ThreadExecutor());
649              }
650 <            public <T,U> CompletableFuture<U> thenCompose
650 >            public <T> CompletableFuture<Void> acceptEither
651                  (CompletableFuture<T> f,
652 <                 Function<? super T,? extends CompletionStage<U>> a) {
653 <                return f.thenComposeAsync(a, new ThreadExecutor());
652 >                 CompletionStage<? extends T> g,
653 >                 Consumer<? super T> a) {
654 >                return f.acceptEitherAsync(g, a, new ThreadExecutor());
655              }
656 <            public <T> CompletableFuture<T> whenComplete
656 >            public <T,U> CompletableFuture<U> applyToEither
657                  (CompletableFuture<T> f,
658 <                 BiConsumer<? super T,? super Throwable> a) {
659 <                return f.whenCompleteAsync(a, new ThreadExecutor());
658 >                 CompletionStage<? extends T> g,
659 >                 Function<? super T,U> a) {
660 >                return f.applyToEitherAsync(g, a, new ThreadExecutor());
661              }
662          };
663  
664 +        public abstract void checkExecutionMode();
665 +        public abstract <T> CompletableFuture<Void> thenRun
666 +            (CompletableFuture<T> f, Runnable a);
667 +        public abstract <T> CompletableFuture<Void> thenAccept
668 +            (CompletableFuture<T> f, Consumer<? super T> a);
669 +        public abstract <T,U> CompletableFuture<U> thenApply
670 +            (CompletableFuture<T> f, Function<? super T,U> a);
671 +        public abstract <T,U> CompletableFuture<U> thenCompose
672 +            (CompletableFuture<T> f,
673 +             Function<? super T,? extends CompletionStage<U>> a);
674 +        public abstract <T,U> CompletableFuture<U> handle
675 +            (CompletableFuture<T> f,
676 +             BiFunction<? super T,Throwable,? extends U> a);
677 +        public abstract <T> CompletableFuture<T> whenComplete
678 +            (CompletableFuture<T> f,
679 +             BiConsumer<? super T,? super Throwable> a);
680          public abstract <T,U> CompletableFuture<Void> runAfterBoth
681              (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
682          public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
# Line 645 | Line 687 | public class CompletableFutureTest exten
687              (CompletableFuture<T> f,
688               CompletionStage<? extends U> g,
689               BiFunction<? super T,? super U,? extends V> a);
648 –        public abstract <T,U> CompletableFuture<U> applyToEither
649 –            (CompletableFuture<T> f,
650 –             CompletionStage<? extends T> g,
651 –             Function<? super T,U> a);
652 –        public abstract <T> CompletableFuture<Void> acceptEither
653 –            (CompletableFuture<T> f,
654 –             CompletionStage<? extends T> g,
655 –             Consumer<? super T> a);
690          public abstract <T> CompletableFuture<Void> runAfterEither
691              (CompletableFuture<T> f,
692               CompletionStage<?> g,
693               java.lang.Runnable a);
694 <        public abstract <T,U> CompletableFuture<U> thenCompose
694 >        public abstract <T> CompletableFuture<Void> acceptEither
695              (CompletableFuture<T> f,
696 <             Function<? super T,? extends CompletionStage<U>> a);
697 <        public abstract <T> CompletableFuture<T> whenComplete
696 >             CompletionStage<? extends T> g,
697 >             Consumer<? super T> a);
698 >        public abstract <T,U> CompletableFuture<U> applyToEither
699              (CompletableFuture<T> f,
700 <             BiConsumer<? super T,? super Throwable> a);
700 >             CompletionStage<? extends T> g,
701 >             Function<? super T,U> a);
702 >    }
703  
704 +    /**
705 +     * exceptionally action is not invoked when source completes
706 +     * normally, and source result is propagated
707 +     */
708 +    public void testExceptionally_normalCompletion() {
709 +        for (boolean createIncomplete : new boolean[] { true, false })
710 +        for (Integer v1 : new Integer[] { 1, null })
711 +    {
712 +        final AtomicInteger a = new AtomicInteger(0);
713 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
714 +        if (!createIncomplete) f.complete(v1);
715 +        final CompletableFuture<Integer> g = f.exceptionally
716 +            ((Throwable t) -> {
717 +                // Should not be called
718 +                a.getAndIncrement();
719 +                throw new AssertionError();
720 +            });
721 +        if (createIncomplete) f.complete(v1);
722 +
723 +        checkCompletedNormally(g, v1);
724 +        checkCompletedNormally(f, v1);
725 +        assertEquals(0, a.get());
726 +    }}
727  
668 –    }
728  
729      /**
730       * exceptionally action completes with function value on source
731 <     * exception; otherwise with source value
731 >     * exception
732       */
733 <    public void testExceptionally() {
734 <        CompletableFuture<Integer> f = new CompletableFuture<>();
735 <        ExceptionToInteger r = new ExceptionToInteger();
736 <        CompletableFuture<Integer> g = f.exceptionally(r);
737 <        f.completeExceptionally(new CFException());
738 <        checkCompletedNormally(g, three);
733 >    public void testExceptionally_exceptionalCompletion() {
734 >        for (boolean createIncomplete : new boolean[] { true, false })
735 >        for (Integer v1 : new Integer[] { 1, null })
736 >    {
737 >        final AtomicInteger a = new AtomicInteger(0);
738 >        final CFException ex = new CFException();
739 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
740 >        if (!createIncomplete) f.completeExceptionally(ex);
741 >        final CompletableFuture<Integer> g = f.exceptionally
742 >            ((Throwable t) -> {
743 >                threadAssertSame(t, ex);
744 >                a.getAndIncrement();
745 >                return v1;
746 >            });
747 >        if (createIncomplete) f.completeExceptionally(ex);
748  
749 <        f = new CompletableFuture<>();
750 <        r = new ExceptionToInteger();
751 <        g = f.exceptionally(r);
752 <        f.complete(one);
753 <        checkCompletedNormally(g, one);
754 <    }
749 >        checkCompletedNormally(g, v1);
750 >        assertEquals(1, a.get());
751 >    }}
752 >
753 >    public void testExceptionally_exceptionalCompletionActionFailed() {
754 >        for (boolean createIncomplete : new boolean[] { true, false })
755 >        for (Integer v1 : new Integer[] { 1, null })
756 >    {
757 >        final AtomicInteger a = new AtomicInteger(0);
758 >        final CFException ex1 = new CFException();
759 >        final CFException ex2 = new CFException();
760 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
761 >        if (!createIncomplete) f.completeExceptionally(ex1);
762 >        final CompletableFuture<Integer> g = f.exceptionally
763 >            ((Throwable t) -> {
764 >                threadAssertSame(t, ex1);
765 >                a.getAndIncrement();
766 >                throw ex2;
767 >            });
768 >        if (createIncomplete) f.completeExceptionally(ex1);
769 >
770 >        checkCompletedWithWrappedCFException(g, ex2);
771 >        assertEquals(1, a.get());
772 >    }}
773  
774      /**
775 <     * handle action completes normally with function value on either
776 <     * normal or exceptional completion of source
775 >     * handle action completes normally with function value on normal
776 >     * completion of source
777       */
778 <    public void testHandle() {
779 <        CompletableFuture<Integer> f, g;
780 <        IntegerHandler r;
778 >    public void testHandle_normalCompletion() {
779 >        for (ExecutionMode m : ExecutionMode.values())
780 >        for (boolean createIncomplete : new boolean[] { true, false })
781 >        for (Integer v1 : new Integer[] { 1, null })
782 >    {
783 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
784 >        final AtomicInteger a = new AtomicInteger(0);
785 >        if (!createIncomplete) f.complete(v1);
786 >        final CompletableFuture<Integer> g = m.handle
787 >            (f,
788 >             (Integer x, Throwable t) -> {
789 >                threadAssertSame(x, v1);
790 >                threadAssertNull(t);
791 >                a.getAndIncrement();
792 >                return inc(v1);
793 >            });
794 >        if (createIncomplete) f.complete(v1);
795  
796 <        f = new CompletableFuture<>();
797 <        f.completeExceptionally(new CFException());
798 <        g = f.handle(r = new IntegerHandler());
799 <        assertEquals(1, r.invocationCount);
700 <        assertEquals(1, r.invocationCount);
701 <        checkCompletedNormally(g, three);
796 >        checkCompletedNormally(g, inc(v1));
797 >        checkCompletedNormally(f, v1);
798 >        assertEquals(1, a.get());
799 >    }}
800  
801 <        f = new CompletableFuture<>();
802 <        g = f.handle(r = new IntegerHandler());
803 <        assertEquals(0, r.invocationCount);
804 <        f.completeExceptionally(new CFException());
805 <        checkCompletedNormally(g, three);
806 <        assertEquals(1, r.invocationCount);
801 >    /**
802 >     * handle action completes normally with function value on
803 >     * exceptional completion of source
804 >     */
805 >    public void testHandle_exceptionalCompletion() {
806 >        for (ExecutionMode m : ExecutionMode.values())
807 >        for (boolean createIncomplete : new boolean[] { true, false })
808 >        for (Integer v1 : new Integer[] { 1, null })
809 >    {
810 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
811 >        final AtomicInteger a = new AtomicInteger(0);
812 >        final CFException ex = new CFException();
813 >        if (!createIncomplete) f.completeExceptionally(ex);
814 >        final CompletableFuture<Integer> g = m.handle
815 >            (f,
816 >             (Integer x, Throwable t) -> {
817 >                threadAssertNull(x);
818 >                threadAssertSame(t, ex);
819 >                a.getAndIncrement();
820 >                return v1;
821 >            });
822 >        if (createIncomplete) f.completeExceptionally(ex);
823  
824 <        f = new CompletableFuture<>();
825 <        f.complete(one);
826 <        g = f.handle(r = new IntegerHandler());
827 <        assertEquals(1, r.invocationCount);
714 <        checkCompletedNormally(g, two);
824 >        checkCompletedNormally(g, v1);
825 >        checkCompletedWithWrappedCFException(f, ex);
826 >        assertEquals(1, a.get());
827 >    }}
828  
829 <        f = new CompletableFuture<>();
830 <        g = f.handle(r = new IntegerHandler());
831 <        assertEquals(0, r.invocationCount);
832 <        f.complete(one);
833 <        assertEquals(1, r.invocationCount);
834 <        checkCompletedNormally(g, two);
835 <    }
829 >    /**
830 >     * handle action completes normally with function value on
831 >     * cancelled source
832 >     */
833 >    public void testHandle_sourceCancelled() {
834 >        for (ExecutionMode m : ExecutionMode.values())
835 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
836 >        for (boolean createIncomplete : new boolean[] { true, false })
837 >        for (Integer v1 : new Integer[] { 1, null })
838 >    {
839 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
840 >        final AtomicInteger a = new AtomicInteger(0);
841 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
842 >        final CompletableFuture<Integer> g = m.handle
843 >            (f,
844 >             (Integer x, Throwable t) -> {
845 >                threadAssertNull(x);
846 >                threadAssertTrue(t instanceof CancellationException);
847 >                a.getAndIncrement();
848 >                return v1;
849 >            });
850 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
851 >
852 >        checkCompletedNormally(g, v1);
853 >        checkCancelled(f);
854 >        assertEquals(1, a.get());
855 >    }}
856 >
857 >    /**
858 >     * handle result completes exceptionally if action does
859 >     */
860 >    public void testHandle_sourceFailedActionFailed() {
861 >        for (ExecutionMode m : ExecutionMode.values())
862 >        for (boolean createIncomplete : new boolean[] { true, false })
863 >    {
864 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
865 >        final AtomicInteger a = new AtomicInteger(0);
866 >        final CFException ex1 = new CFException();
867 >        final CFException ex2 = new CFException();
868 >        if (!createIncomplete) f.completeExceptionally(ex1);
869 >        final CompletableFuture<Integer> g = m.handle
870 >            (f,
871 >             (Integer x, Throwable t) -> {
872 >                threadAssertNull(x);
873 >                threadAssertSame(ex1, t);
874 >                a.getAndIncrement();
875 >                throw ex2;
876 >            });
877 >        if (createIncomplete) f.completeExceptionally(ex1);
878 >
879 >        checkCompletedWithWrappedCFException(g, ex2);
880 >        checkCompletedWithWrappedCFException(f, ex1);
881 >        assertEquals(1, a.get());
882 >    }}
883 >
884 >    public void testHandle_sourceCompletedNormallyActionFailed() {
885 >        for (ExecutionMode m : ExecutionMode.values())
886 >        for (boolean createIncomplete : new boolean[] { true, false })
887 >        for (Integer v1 : new Integer[] { 1, null })
888 >    {
889 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
890 >        final AtomicInteger a = new AtomicInteger(0);
891 >        final CFException ex = new CFException();
892 >        if (!createIncomplete) f.complete(v1);
893 >        final CompletableFuture<Integer> g = m.handle
894 >            (f,
895 >             (Integer x, Throwable t) -> {
896 >                threadAssertSame(x, v1);
897 >                threadAssertNull(t);
898 >                a.getAndIncrement();
899 >                throw ex;
900 >            });
901 >        if (createIncomplete) f.complete(v1);
902 >
903 >        checkCompletedWithWrappedCFException(g, ex);
904 >        checkCompletedNormally(f, v1);
905 >        assertEquals(1, a.get());
906 >    }}
907  
908      /**
909       * runAsync completes after running Runnable
# Line 749 | Line 933 | public class CompletableFutureTest exten
933       * failing runAsync completes exceptionally after running Runnable
934       */
935      public void testRunAsync3() {
936 <        FailingNoop r = new FailingNoop();
936 >        FailingRunnable r = new FailingRunnable();
937          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
938          checkCompletedWithWrappedCFException(f);
939          assertEquals(1, r.invocationCount);
# Line 790 | Line 974 | public class CompletableFutureTest exten
974      /**
975       * thenRun result completes normally after normal completion of source
976       */
977 <    public void testThenRun() {
978 <        CompletableFuture<Integer> f;
979 <        CompletableFuture<Void> g;
980 <        Noop r;
981 <
982 <        f = new CompletableFuture<>();
983 <        g = f.thenRun(r = new Noop());
984 <        f.complete(null);
985 <        checkCompletedNormally(g, null);
986 <        assertEquals(1, r.invocationCount);
977 >    public void testThenRun_normalCompletion() {
978 >        for (ExecutionMode m : ExecutionMode.values())
979 >        for (boolean createIncomplete : new boolean[] { true, false })
980 >        for (Integer v1 : new Integer[] { 1, null })
981 >    {
982 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
983 >        final Noop r = new Noop();
984 >        if (!createIncomplete) f.complete(v1);
985 >        final CompletableFuture<Void> g = m.thenRun(f, r);
986 >        if (createIncomplete) {
987 >            checkIncomplete(g);
988 >            f.complete(v1);
989 >        }
990  
804 –        f = new CompletableFuture<>();
805 –        f.complete(null);
806 –        g = f.thenRun(r = new Noop());
991          checkCompletedNormally(g, null);
992 +        checkCompletedNormally(f, v1);
993          assertEquals(1, r.invocationCount);
994 <    }
994 >    }}
995  
996      /**
997       * thenRun result completes exceptionally after exceptional
998       * completion of source
999       */
1000 <    public void testThenRun2() {
1001 <        CompletableFuture<Integer> f;
1002 <        CompletableFuture<Void> g;
1003 <        Noop r;
1004 <
1005 <        f = new CompletableFuture<>();
1006 <        g = f.thenRun(r = new Noop());
1007 <        f.completeExceptionally(new CFException());
1008 <        checkCompletedWithWrappedCFException(g);
1009 <        assertEquals(0, r.invocationCount);
1000 >    public void testThenRun_exceptionalCompletion() {
1001 >        for (ExecutionMode m : ExecutionMode.values())
1002 >        for (boolean createIncomplete : new boolean[] { true, false })
1003 >    {
1004 >        final CFException ex = new CFException();
1005 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1006 >        final Noop r = new Noop();
1007 >        if (!createIncomplete) f.completeExceptionally(ex);
1008 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1009 >        if (createIncomplete) {
1010 >            checkIncomplete(g);
1011 >            f.completeExceptionally(ex);
1012 >        }
1013  
1014 <        f = new CompletableFuture<>();
1015 <        f.completeExceptionally(new CFException());
828 <        g = f.thenRun(r = new Noop());
829 <        checkCompletedWithWrappedCFException(g);
1014 >        checkCompletedWithWrappedCFException(g, ex);
1015 >        checkCompletedWithWrappedCFException(f, ex);
1016          assertEquals(0, r.invocationCount);
1017 <    }
1017 >    }}
1018  
1019      /**
1020 <     * thenRun result completes exceptionally if action does
1020 >     * thenRun result completes exceptionally if source cancelled
1021       */
1022 <    public void testThenRun3() {
1023 <        CompletableFuture<Integer> f;
1024 <        CompletableFuture<Void> g;
1025 <        FailingNoop r;
1026 <
1027 <        f = new CompletableFuture<>();
1028 <        g = f.thenRun(r = new FailingNoop());
1029 <        f.complete(null);
1030 <        checkCompletedWithWrappedCFException(g);
1022 >    public void testThenRun_sourceCancelled() {
1023 >        for (ExecutionMode m : ExecutionMode.values())
1024 >        for (boolean createIncomplete : new boolean[] { true, false })
1025 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1026 >    {
1027 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1028 >        final Noop r = new Noop();
1029 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1030 >        final CompletableFuture<Void> g = f.thenRun(r);
1031 >        if (createIncomplete) {
1032 >            checkIncomplete(g);
1033 >            assertTrue(f.cancel(mayInterruptIfRunning));
1034 >        }
1035  
1036 <        f = new CompletableFuture<>();
1037 <        f.complete(null);
1038 <        g = f.thenRun(r = new FailingNoop());
1039 <        checkCompletedWithWrappedCFException(g);
850 <    }
1036 >        checkCompletedWithWrappedCancellationException(g);
1037 >        checkCancelled(f);
1038 >        assertEquals(0, r.invocationCount);
1039 >    }}
1040  
1041      /**
1042 <     * thenRun result completes exceptionally if source cancelled
1042 >     * thenRun result completes exceptionally if action does
1043       */
1044 <    public void testThenRun4() {
1045 <        CompletableFuture<Integer> f;
1046 <        CompletableFuture<Void> g;
1047 <        Noop r;
1048 <
1049 <        f = new CompletableFuture<>();
1050 <        g = f.thenRun(r = new Noop());
1051 <        assertTrue(f.cancel(true));
1052 <        checkCompletedWithWrappedCancellationException(g);
1044 >    public void testThenRun_actionFailed() {
1045 >        for (ExecutionMode m : ExecutionMode.values())
1046 >        for (boolean createIncomplete : new boolean[] { true, false })
1047 >        for (Integer v1 : new Integer[] { 1, null })
1048 >    {
1049 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1050 >        final FailingRunnable r = new FailingRunnable();
1051 >        if (!createIncomplete) f.complete(v1);
1052 >        final CompletableFuture<Void> g = f.thenRun(r);
1053 >        if (createIncomplete) {
1054 >            checkIncomplete(g);
1055 >            f.complete(v1);
1056 >        }
1057  
1058 <        f = new CompletableFuture<>();
1059 <        assertTrue(f.cancel(true));
1060 <        g = f.thenRun(r = new Noop());
868 <        checkCompletedWithWrappedCancellationException(g);
869 <    }
1058 >        checkCompletedWithWrappedCFException(g);
1059 >        checkCompletedNormally(f, v1);
1060 >    }}
1061  
1062      /**
1063       * thenApply result completes normally after normal completion of source
1064       */
1065 <    public void testThenApply() {
1066 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1067 <        CompletableFuture<Integer> g = f.thenApply(inc);
1068 <        f.complete(one);
1069 <        checkCompletedNormally(g, two);
1070 <    }
1065 >    public void testThenApply_normalCompletion() {
1066 >        for (ExecutionMode m : ExecutionMode.values())
1067 >        for (boolean createIncomplete : new boolean[] { true, false })
1068 >        for (Integer v1 : new Integer[] { 1, null })
1069 >    {
1070 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1071 >        final IncFunction r = new IncFunction();
1072 >        if (!createIncomplete) f.complete(v1);
1073 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1074 >        if (createIncomplete) {
1075 >            checkIncomplete(g);
1076 >            f.complete(v1);
1077 >        }
1078 >
1079 >        checkCompletedNormally(g, inc(v1));
1080 >        checkCompletedNormally(f, v1);
1081 >        assertEquals(1, r.invocationCount);
1082 >    }}
1083  
1084      /**
1085       * thenApply result completes exceptionally after exceptional
1086       * completion of source
1087       */
1088 <    public void testThenApply2() {
1089 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1090 <        CompletableFuture<Integer> g = f.thenApply(inc);
1091 <        f.completeExceptionally(new CFException());
1092 <        checkCompletedWithWrappedCFException(g);
1093 <    }
1088 >    public void testThenApply_exceptionalCompletion() {
1089 >        for (ExecutionMode m : ExecutionMode.values())
1090 >        for (boolean createIncomplete : new boolean[] { true, false })
1091 >    {
1092 >        final CFException ex = new CFException();
1093 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1094 >        final IncFunction r = new IncFunction();
1095 >        if (!createIncomplete) f.completeExceptionally(ex);
1096 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1097 >        if (createIncomplete) {
1098 >            checkIncomplete(g);
1099 >            f.completeExceptionally(ex);
1100 >        }
1101  
1102 <    /**
1103 <     * thenApply result completes exceptionally if action does
1104 <     */
1105 <    public void testThenApply3() {
896 <        CompletableFuture<Integer> f = new CompletableFuture<>();
897 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
898 <        f.complete(one);
899 <        checkCompletedWithWrappedCFException(g);
900 <    }
1102 >        checkCompletedWithWrappedCFException(g, ex);
1103 >        checkCompletedWithWrappedCFException(f, ex);
1104 >        assertEquals(0, r.invocationCount);
1105 >    }}
1106  
1107      /**
1108       * thenApply result completes exceptionally if source cancelled
1109       */
1110 <    public void testThenApply4() {
1111 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1112 <        CompletableFuture<Integer> g = f.thenApply(inc);
1113 <        assertTrue(f.cancel(true));
1110 >    public void testThenApply_sourceCancelled() {
1111 >        for (ExecutionMode m : ExecutionMode.values())
1112 >        for (boolean createIncomplete : new boolean[] { true, false })
1113 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1114 >    {
1115 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1116 >        final IncFunction r = new IncFunction();
1117 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1118 >        final CompletableFuture<Integer> g = f.thenApply(r);
1119 >        if (createIncomplete) {
1120 >            checkIncomplete(g);
1121 >            assertTrue(f.cancel(mayInterruptIfRunning));
1122 >        }
1123 >
1124          checkCompletedWithWrappedCancellationException(g);
1125 <    }
1125 >        checkCancelled(f);
1126 >        assertEquals(0, r.invocationCount);
1127 >    }}
1128 >
1129 >    /**
1130 >     * thenApply result completes exceptionally if action does
1131 >     */
1132 >    public void testThenApply_actionFailed() {
1133 >        for (ExecutionMode m : ExecutionMode.values())
1134 >        for (boolean createIncomplete : new boolean[] { true, false })
1135 >        for (Integer v1 : new Integer[] { 1, null })
1136 >    {
1137 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1138 >        final FailingFunction r = new FailingFunction();
1139 >        if (!createIncomplete) f.complete(v1);
1140 >        final CompletableFuture<Integer> g = f.thenApply(r);
1141 >        if (createIncomplete) {
1142 >            checkIncomplete(g);
1143 >            f.complete(v1);
1144 >        }
1145 >
1146 >        checkCompletedWithWrappedCFException(g);
1147 >        checkCompletedNormally(f, v1);
1148 >    }}
1149  
1150      /**
1151       * thenAccept result completes normally after normal completion of source
1152       */
1153 <    public void testThenAccept() {
1154 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1155 <        IncAction r = new IncAction();
1156 <        CompletableFuture<Void> g = f.thenAccept(r);
1157 <        f.complete(one);
1153 >    public void testThenAccept_normalCompletion() {
1154 >        for (ExecutionMode m : ExecutionMode.values())
1155 >        for (boolean createIncomplete : new boolean[] { true, false })
1156 >        for (Integer v1 : new Integer[] { 1, null })
1157 >    {
1158 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1159 >        final IncAction r = new IncAction();
1160 >        if (!createIncomplete) f.complete(v1);
1161 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1162 >        if (createIncomplete) {
1163 >            checkIncomplete(g);
1164 >            f.complete(v1);
1165 >        }
1166 >
1167          checkCompletedNormally(g, null);
1168 <        assertEquals(r.value, (Integer) 2);
1169 <    }
1168 >        checkCompletedNormally(f, v1);
1169 >        assertEquals(1, r.invocationCount);
1170 >        assertEquals(inc(v1), r.value);
1171 >    }}
1172  
1173      /**
1174       * thenAccept result completes exceptionally after exceptional
1175       * completion of source
1176       */
1177 <    public void testThenAccept2() {
1178 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1179 <        IncAction r = new IncAction();
1180 <        CompletableFuture<Void> g = f.thenAccept(r);
1181 <        f.completeExceptionally(new CFException());
1182 <        checkCompletedWithWrappedCFException(g);
1183 <    }
1177 >    public void testThenAccept_exceptionalCompletion() {
1178 >        for (ExecutionMode m : ExecutionMode.values())
1179 >        for (boolean createIncomplete : new boolean[] { true, false })
1180 >    {
1181 >        final CFException ex = new CFException();
1182 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1183 >        final IncAction r = new IncAction();
1184 >        if (!createIncomplete) f.completeExceptionally(ex);
1185 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1186 >        if (createIncomplete) {
1187 >            checkIncomplete(g);
1188 >            f.completeExceptionally(ex);
1189 >        }
1190 >
1191 >        checkCompletedWithWrappedCFException(g, ex);
1192 >        checkCompletedWithWrappedCFException(f, ex);
1193 >        assertEquals(0, r.invocationCount);
1194 >    }}
1195  
1196      /**
1197       * thenAccept result completes exceptionally if action does
1198       */
1199 <    public void testThenAccept3() {
1200 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1201 <        FailingConsumer r = new FailingConsumer();
1202 <        CompletableFuture<Void> g = f.thenAccept(r);
1203 <        f.complete(one);
1199 >    public void testThenAccept_actionFailed() {
1200 >        for (ExecutionMode m : ExecutionMode.values())
1201 >        for (boolean createIncomplete : new boolean[] { true, false })
1202 >        for (Integer v1 : new Integer[] { 1, null })
1203 >    {
1204 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1205 >        final FailingConsumer r = new FailingConsumer();
1206 >        if (!createIncomplete) f.complete(v1);
1207 >        final CompletableFuture<Void> g = f.thenAccept(r);
1208 >        if (createIncomplete) {
1209 >            checkIncomplete(g);
1210 >            f.complete(v1);
1211 >        }
1212 >
1213          checkCompletedWithWrappedCFException(g);
1214 <        assertEquals(1, r.invocationCount);
1215 <    }
1214 >        checkCompletedNormally(f, v1);
1215 >    }}
1216  
1217      /**
1218       * thenAccept result completes exceptionally if source cancelled
1219       */
1220 <    public void testThenAccept4() {
1221 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1222 <        IncAction r = new IncAction();
1223 <        CompletableFuture<Void> g = f.thenAccept(r);
1224 <        assertTrue(f.cancel(true));
1220 >    public void testThenAccept_sourceCancelled() {
1221 >        for (ExecutionMode m : ExecutionMode.values())
1222 >        for (boolean createIncomplete : new boolean[] { true, false })
1223 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1224 >    {
1225 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1226 >        final IncAction r = new IncAction();
1227 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1228 >        final CompletableFuture<Void> g = f.thenAccept(r);
1229 >        if (createIncomplete) {
1230 >            checkIncomplete(g);
1231 >            assertTrue(f.cancel(mayInterruptIfRunning));
1232 >        }
1233 >
1234          checkCompletedWithWrappedCancellationException(g);
1235 <    }
1235 >        checkCancelled(f);
1236 >        assertEquals(0, r.invocationCount);
1237 >    }}
1238  
1239      /**
1240       * thenCombine result completes normally after normal completion
1241       * of sources
1242       */
1243 <    public void testThenCombine_normalCompletion1() {
1243 >    public void testThenCombine_normalCompletion() {
1244 >        for (ExecutionMode m : ExecutionMode.values())
1245          for (boolean createIncomplete : new boolean[] { true, false })
1246          for (boolean fFirst : new boolean[] { true, false })
966 –        for (ExecutionMode m : ExecutionMode.values())
1247          for (Integer v1 : new Integer[] { 1, null })
1248 <        for (Integer v2 : new Integer[] { 2, null }) {
1249 <
1248 >        for (Integer v2 : new Integer[] { 2, null })
1249 >    {
1250          final CompletableFuture<Integer> f = new CompletableFuture<>();
1251          final CompletableFuture<Integer> g = new CompletableFuture<>();
1252          final SubtractFunction r = new SubtractFunction();
973 –        CompletableFuture<Integer> h = null;
974 –        if (createIncomplete) h = m.thenCombine(f, g, r);
1253  
1254 <        if (fFirst)
1255 <            f.complete(v1);
1256 <        else
1257 <            g.complete(v2);
1258 <        if (createIncomplete) checkIncomplete(h);
1259 <        assertEquals(0, r.invocationCount);
1260 <        if (!fFirst)
1261 <            f.complete(v1);
1262 <        else
985 <            g.complete(v2);
986 <        if (!createIncomplete) h = m.thenCombine(f, g, r);
1254 >        if (fFirst) f.complete(v1); else g.complete(v2);
1255 >        if (!createIncomplete)
1256 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1257 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1258 >        if (createIncomplete) {
1259 >            checkIncomplete(h);
1260 >            assertEquals(0, r.invocationCount);
1261 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1262 >        }
1263  
1264          checkCompletedNormally(h, subtract(v1, v2));
1265          checkCompletedNormally(f, v1);
1266          checkCompletedNormally(g, v2);
1267          assertEquals(1, r.invocationCount);
1268 <        }
993 <    }
1268 >    }}
1269  
1270      /**
1271       * thenCombine result completes exceptionally after exceptional
1272       * completion of either source
1273       */
1274 <    public void testThenCombine_exceptionalCompletion1() {
1000 <        for (ExecutionMode m : ExecutionMode.values())
1001 <        for (Integer v1 : new Integer[] { 1, null }) {
1002 <
1003 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1004 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1005 <        final SubtractFunction r = new SubtractFunction();
1006 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1007 <        final CFException ex = new CFException();
1008 <
1009 <        f.completeExceptionally(ex);
1010 <        checkIncomplete(h);
1011 <        g.complete(v1);
1012 <
1013 <        checkCompletedWithWrappedCFException(h, ex);
1014 <        checkCompletedWithWrappedCFException(f, ex);
1015 <        assertEquals(0, r.invocationCount);
1016 <        checkCompletedNormally(g, v1);
1017 <        }
1018 <    }
1019 <
1020 <    public void testThenCombine_exceptionalCompletion2() {
1274 >    public void testThenCombine_exceptionalCompletion() {
1275          for (ExecutionMode m : ExecutionMode.values())
1276 <        for (Integer v1 : new Integer[] { 1, null }) {
1277 <
1276 >        for (boolean createIncomplete : new boolean[] { true, false })
1277 >        for (boolean fFirst : new boolean[] { true, false })
1278 >        for (Integer v1 : new Integer[] { 1, null })
1279 >    {
1280          final CompletableFuture<Integer> f = new CompletableFuture<>();
1281          final CompletableFuture<Integer> g = new CompletableFuture<>();
1026 –        final SubtractFunction r = new SubtractFunction();
1027 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1282          final CFException ex = new CFException();
1029 –
1030 –        g.completeExceptionally(ex);
1031 –        checkIncomplete(h);
1032 –        f.complete(v1);
1033 –
1034 –        checkCompletedWithWrappedCFException(h, ex);
1035 –        checkCompletedWithWrappedCFException(g, ex);
1036 –        assertEquals(0, r.invocationCount);
1037 –        checkCompletedNormally(f, v1);
1038 –        }
1039 –    }
1040 –
1041 –    public void testThenCombine_exceptionalCompletion3() {
1042 –        for (ExecutionMode m : ExecutionMode.values())
1043 –        for (Integer v1 : new Integer[] { 1, null }) {
1044 –
1045 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1046 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1283          final SubtractFunction r = new SubtractFunction();
1048 –        final CFException ex = new CFException();
1284  
1285 <        g.completeExceptionally(ex);
1286 <        f.complete(v1);
1285 >        (fFirst ? f : g).complete(v1);
1286 >        if (!createIncomplete)
1287 >            (!fFirst ? f : g).completeExceptionally(ex);
1288          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1289 <
1290 <        checkCompletedWithWrappedCFException(h, ex);
1291 <        checkCompletedWithWrappedCFException(g, ex);
1056 <        assertEquals(0, r.invocationCount);
1057 <        checkCompletedNormally(f, v1);
1289 >        if (createIncomplete) {
1290 >            checkIncomplete(h);
1291 >            (!fFirst ? f : g).completeExceptionally(ex);
1292          }
1059 –    }
1060 –
1061 –    public void testThenCombine_exceptionalCompletion4() {
1062 –        for (ExecutionMode m : ExecutionMode.values())
1063 –        for (Integer v1 : new Integer[] { 1, null }) {
1064 –
1065 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1066 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1067 –        final SubtractFunction r = new SubtractFunction();
1068 –        final CFException ex = new CFException();
1069 –
1070 –        f.completeExceptionally(ex);
1071 –        g.complete(v1);
1072 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1293  
1294          checkCompletedWithWrappedCFException(h, ex);
1075 –        checkCompletedWithWrappedCFException(f, ex);
1295          assertEquals(0, r.invocationCount);
1296 <        checkCompletedNormally(g, v1);
1297 <        }
1298 <    }
1296 >        checkCompletedNormally(fFirst ? f : g, v1);
1297 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1298 >    }}
1299  
1300      /**
1301       * thenCombine result completes exceptionally if action does
1302       */
1303 <    public void testThenCombine_actionFailed1() {
1303 >    public void testThenCombine_actionFailed() {
1304          for (ExecutionMode m : ExecutionMode.values())
1305 +        for (boolean fFirst : new boolean[] { true, false })
1306          for (Integer v1 : new Integer[] { 1, null })
1307 <        for (Integer v2 : new Integer[] { 2, null }) {
1308 <
1307 >        for (Integer v2 : new Integer[] { 2, null })
1308 >    {
1309          final CompletableFuture<Integer> f = new CompletableFuture<>();
1310          final CompletableFuture<Integer> g = new CompletableFuture<>();
1311          final FailingBiFunction r = new FailingBiFunction();
1312          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1313  
1314 <        f.complete(v1);
1315 <        checkIncomplete(h);
1316 <        g.complete(v2);
1317 <
1318 <        checkCompletedWithWrappedCFException(h);
1319 <        checkCompletedNormally(f, v1);
1100 <        checkCompletedNormally(g, v2);
1314 >        if (fFirst) {
1315 >            f.complete(v1);
1316 >            g.complete(v2);
1317 >        } else {
1318 >            g.complete(v2);
1319 >            f.complete(v1);
1320          }
1102 –    }
1103 –
1104 –    public void testThenCombine_actionFailed2() {
1105 –        for (ExecutionMode m : ExecutionMode.values())
1106 –        for (Integer v1 : new Integer[] { 1, null })
1107 –        for (Integer v2 : new Integer[] { 2, null }) {
1108 –
1109 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1110 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1111 –        final FailingBiFunction r = new FailingBiFunction();
1112 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1113 –
1114 –        g.complete(v2);
1115 –        checkIncomplete(h);
1116 –        f.complete(v1);
1321  
1322          checkCompletedWithWrappedCFException(h);
1323          checkCompletedNormally(f, v1);
1324          checkCompletedNormally(g, v2);
1325 <        }
1122 <    }
1325 >    }}
1326  
1327      /**
1328       * thenCombine result completes exceptionally if either source cancelled
1329       */
1330 <    public void testThenCombine_sourceCancelled1() {
1128 <        for (ExecutionMode m : ExecutionMode.values())
1129 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1130 <        for (Integer v1 : new Integer[] { 1, null }) {
1131 <
1132 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1133 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1134 <        final SubtractFunction r = new SubtractFunction();
1135 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1136 <
1137 <        assertTrue(f.cancel(mayInterruptIfRunning));
1138 <        checkIncomplete(h);
1139 <        g.complete(v1);
1140 <
1141 <        checkCompletedWithWrappedCancellationException(h);
1142 <        checkCancelled(f);
1143 <        assertEquals(0, r.invocationCount);
1144 <        checkCompletedNormally(g, v1);
1145 <        }
1146 <    }
1147 <
1148 <    public void testThenCombine_sourceCancelled2() {
1149 <        for (ExecutionMode m : ExecutionMode.values())
1150 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1151 <        for (Integer v1 : new Integer[] { 1, null }) {
1152 <
1153 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1154 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1155 <        final SubtractFunction r = new SubtractFunction();
1156 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1157 <
1158 <        assertTrue(g.cancel(mayInterruptIfRunning));
1159 <        checkIncomplete(h);
1160 <        f.complete(v1);
1161 <
1162 <        checkCompletedWithWrappedCancellationException(h);
1163 <        checkCancelled(g);
1164 <        assertEquals(0, r.invocationCount);
1165 <        checkCompletedNormally(f, v1);
1166 <        }
1167 <    }
1168 <
1169 <    public void testThenCombine_sourceCancelled3() {
1330 >    public void testThenCombine_sourceCancelled() {
1331          for (ExecutionMode m : ExecutionMode.values())
1332          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1333 <        for (Integer v1 : new Integer[] { 1, null }) {
1334 <
1333 >        for (boolean createIncomplete : new boolean[] { true, false })
1334 >        for (boolean fFirst : new boolean[] { true, false })
1335 >        for (Integer v1 : new Integer[] { 1, null })
1336 >    {
1337          final CompletableFuture<Integer> f = new CompletableFuture<>();
1338          final CompletableFuture<Integer> g = new CompletableFuture<>();
1339          final SubtractFunction r = new SubtractFunction();
1340  
1341 <        assertTrue(g.cancel(mayInterruptIfRunning));
1342 <        f.complete(v1);
1341 >        (fFirst ? f : g).complete(v1);
1342 >        if (!createIncomplete)
1343 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1344          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1345 <
1346 <        checkCompletedWithWrappedCancellationException(h);
1347 <        checkCancelled(g);
1184 <        assertEquals(0, r.invocationCount);
1185 <        checkCompletedNormally(f, v1);
1345 >        if (createIncomplete) {
1346 >            checkIncomplete(h);
1347 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1348          }
1187 –    }
1188 –
1189 –    public void testThenCombine_sourceCancelled4() {
1190 –        for (ExecutionMode m : ExecutionMode.values())
1191 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1192 –        for (Integer v1 : new Integer[] { 1, null }) {
1193 –
1194 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1195 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1196 –        final SubtractFunction r = new SubtractFunction();
1197 –
1198 –        assertTrue(f.cancel(mayInterruptIfRunning));
1199 –        g.complete(v1);
1200 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1349  
1350          checkCompletedWithWrappedCancellationException(h);
1351 <        checkCancelled(f);
1351 >        checkCancelled(!fFirst ? f : g);
1352          assertEquals(0, r.invocationCount);
1353 <        checkCompletedNormally(g, v1);
1354 <        }
1207 <    }
1353 >        checkCompletedNormally(fFirst ? f : g, v1);
1354 >    }}
1355  
1356      /**
1357       * thenAcceptBoth result completes normally after normal
1358       * completion of sources
1359       */
1360 <    public void testThenAcceptBoth_normalCompletion1() {
1214 <        for (ExecutionMode m : ExecutionMode.values())
1215 <        for (Integer v1 : new Integer[] { 1, null })
1216 <        for (Integer v2 : new Integer[] { 2, null }) {
1217 <
1218 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1219 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1220 <        final SubtractAction r = new SubtractAction();
1221 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1222 <
1223 <        f.complete(v1);
1224 <        checkIncomplete(h);
1225 <        assertEquals(0, r.invocationCount);
1226 <        g.complete(v2);
1227 <
1228 <        checkCompletedNormally(h, null);
1229 <        assertEquals(r.value, subtract(v1, v2));
1230 <        checkCompletedNormally(f, v1);
1231 <        checkCompletedNormally(g, v2);
1232 <        }
1233 <    }
1234 <
1235 <    public void testThenAcceptBoth_normalCompletion2() {
1236 <        for (ExecutionMode m : ExecutionMode.values())
1237 <        for (Integer v1 : new Integer[] { 1, null })
1238 <        for (Integer v2 : new Integer[] { 2, null }) {
1239 <
1240 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1241 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1242 <        final SubtractAction r = new SubtractAction();
1243 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1244 <
1245 <        g.complete(v2);
1246 <        checkIncomplete(h);
1247 <        assertEquals(0, r.invocationCount);
1248 <        f.complete(v1);
1249 <
1250 <        checkCompletedNormally(h, null);
1251 <        assertEquals(r.value, subtract(v1, v2));
1252 <        checkCompletedNormally(f, v1);
1253 <        checkCompletedNormally(g, v2);
1254 <        }
1255 <    }
1256 <
1257 <    public void testThenAcceptBoth_normalCompletion3() {
1360 >    public void testThenAcceptBoth_normalCompletion() {
1361          for (ExecutionMode m : ExecutionMode.values())
1362 +        for (boolean createIncomplete : new boolean[] { true, false })
1363 +        for (boolean fFirst : new boolean[] { true, false })
1364          for (Integer v1 : new Integer[] { 1, null })
1365 <        for (Integer v2 : new Integer[] { 2, null }) {
1366 <
1365 >        for (Integer v2 : new Integer[] { 2, null })
1366 >    {
1367          final CompletableFuture<Integer> f = new CompletableFuture<>();
1368          final CompletableFuture<Integer> g = new CompletableFuture<>();
1369          final SubtractAction r = new SubtractAction();
1370  
1371 <        g.complete(v2);
1372 <        f.complete(v1);
1371 >        if (fFirst) f.complete(v1); else g.complete(v2);
1372 >        if (!createIncomplete)
1373 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1374          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1375 <
1376 <        checkCompletedNormally(h, null);
1377 <        assertEquals(r.value, subtract(v1, v2));
1378 <        checkCompletedNormally(f, v1);
1273 <        checkCompletedNormally(g, v2);
1375 >        if (createIncomplete) {
1376 >            checkIncomplete(h);
1377 >            assertEquals(0, r.invocationCount);
1378 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1379          }
1275 –    }
1276 –
1277 –    public void testThenAcceptBoth_normalCompletion4() {
1278 –        for (ExecutionMode m : ExecutionMode.values())
1279 –        for (Integer v1 : new Integer[] { 1, null })
1280 –        for (Integer v2 : new Integer[] { 2, null }) {
1281 –
1282 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1283 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1284 –        final SubtractAction r = new SubtractAction();
1285 –
1286 –        f.complete(v1);
1287 –        g.complete(v2);
1288 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1380  
1381          checkCompletedNormally(h, null);
1382 <        assertEquals(r.value, subtract(v1, v2));
1382 >        assertEquals(subtract(v1, v2), r.value);
1383          checkCompletedNormally(f, v1);
1384          checkCompletedNormally(g, v2);
1385 <        }
1295 <    }
1385 >    }}
1386  
1387      /**
1388       * thenAcceptBoth result completes exceptionally after exceptional
1389       * completion of either source
1390       */
1391 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1302 <        for (ExecutionMode m : ExecutionMode.values())
1303 <        for (Integer v1 : new Integer[] { 1, null }) {
1304 <
1305 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1306 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1307 <        final SubtractAction r = new SubtractAction();
1308 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1309 <        final CFException ex = new CFException();
1310 <
1311 <        f.completeExceptionally(ex);
1312 <        checkIncomplete(h);
1313 <        g.complete(v1);
1314 <
1315 <        checkCompletedWithWrappedCFException(h, ex);
1316 <        checkCompletedWithWrappedCFException(f, ex);
1317 <        assertEquals(0, r.invocationCount);
1318 <        checkCompletedNormally(g, v1);
1319 <        }
1320 <    }
1321 <
1322 <    public void testThenAcceptBoth_exceptionalCompletion2() {
1391 >    public void testThenAcceptBoth_exceptionalCompletion() {
1392          for (ExecutionMode m : ExecutionMode.values())
1393 <        for (Integer v1 : new Integer[] { 1, null }) {
1394 <
1393 >        for (boolean createIncomplete : new boolean[] { true, false })
1394 >        for (boolean fFirst : new boolean[] { true, false })
1395 >        for (Integer v1 : new Integer[] { 1, null })
1396 >    {
1397          final CompletableFuture<Integer> f = new CompletableFuture<>();
1398          final CompletableFuture<Integer> g = new CompletableFuture<>();
1328 –        final SubtractAction r = new SubtractAction();
1329 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1399          final CFException ex = new CFException();
1331 –
1332 –        g.completeExceptionally(ex);
1333 –        checkIncomplete(h);
1334 –        f.complete(v1);
1335 –
1336 –        checkCompletedWithWrappedCFException(h, ex);
1337 –        checkCompletedWithWrappedCFException(g, ex);
1338 –        assertEquals(0, r.invocationCount);
1339 –        checkCompletedNormally(f, v1);
1340 –        }
1341 –    }
1342 –
1343 –    public void testThenAcceptBoth_exceptionalCompletion3() {
1344 –        for (ExecutionMode m : ExecutionMode.values())
1345 –        for (Integer v1 : new Integer[] { 1, null }) {
1346 –
1347 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1348 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1400          final SubtractAction r = new SubtractAction();
1350 –        final CFException ex = new CFException();
1401  
1402 <        g.completeExceptionally(ex);
1403 <        f.complete(v1);
1402 >        (fFirst ? f : g).complete(v1);
1403 >        if (!createIncomplete)
1404 >            (!fFirst ? f : g).completeExceptionally(ex);
1405          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1406 <
1407 <        checkCompletedWithWrappedCFException(h, ex);
1408 <        checkCompletedWithWrappedCFException(g, ex);
1358 <        assertEquals(0, r.invocationCount);
1359 <        checkCompletedNormally(f, v1);
1406 >        if (createIncomplete) {
1407 >            checkIncomplete(h);
1408 >            (!fFirst ? f : g).completeExceptionally(ex);
1409          }
1361 –    }
1362 –
1363 –    public void testThenAcceptBoth_exceptionalCompletion4() {
1364 –        for (ExecutionMode m : ExecutionMode.values())
1365 –        for (Integer v1 : new Integer[] { 1, null }) {
1366 –
1367 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1368 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1369 –        final SubtractAction r = new SubtractAction();
1370 –        final CFException ex = new CFException();
1371 –
1372 –        f.completeExceptionally(ex);
1373 –        g.complete(v1);
1374 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1410  
1411          checkCompletedWithWrappedCFException(h, ex);
1377 –        checkCompletedWithWrappedCFException(f, ex);
1412          assertEquals(0, r.invocationCount);
1413 <        checkCompletedNormally(g, v1);
1414 <        }
1415 <    }
1413 >        checkCompletedNormally(fFirst ? f : g, v1);
1414 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1415 >    }}
1416  
1417      /**
1418       * thenAcceptBoth result completes exceptionally if action does
1419       */
1420 <    public void testThenAcceptBoth_actionFailed1() {
1420 >    public void testThenAcceptBoth_actionFailed() {
1421          for (ExecutionMode m : ExecutionMode.values())
1422 +        for (boolean fFirst : new boolean[] { true, false })
1423          for (Integer v1 : new Integer[] { 1, null })
1424 <        for (Integer v2 : new Integer[] { 2, null }) {
1425 <
1424 >        for (Integer v2 : new Integer[] { 2, null })
1425 >    {
1426          final CompletableFuture<Integer> f = new CompletableFuture<>();
1427          final CompletableFuture<Integer> g = new CompletableFuture<>();
1428          final FailingBiConsumer r = new FailingBiConsumer();
1429          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1430  
1431 <        f.complete(v1);
1432 <        checkIncomplete(h);
1433 <        g.complete(v2);
1434 <
1435 <        checkCompletedWithWrappedCFException(h);
1436 <        checkCompletedNormally(f, v1);
1402 <        checkCompletedNormally(g, v2);
1431 >        if (fFirst) {
1432 >            f.complete(v1);
1433 >            g.complete(v2);
1434 >        } else {
1435 >            g.complete(v2);
1436 >            f.complete(v1);
1437          }
1404 –    }
1405 –
1406 –    public void testThenAcceptBoth_actionFailed2() {
1407 –        for (ExecutionMode m : ExecutionMode.values())
1408 –        for (Integer v1 : new Integer[] { 1, null })
1409 –        for (Integer v2 : new Integer[] { 2, null }) {
1410 –
1411 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1412 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1413 –        final FailingBiConsumer r = new FailingBiConsumer();
1414 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1415 –
1416 –        g.complete(v2);
1417 –        checkIncomplete(h);
1418 –        f.complete(v1);
1438  
1439          checkCompletedWithWrappedCFException(h);
1440          checkCompletedNormally(f, v1);
1441          checkCompletedNormally(g, v2);
1442 <        }
1424 <    }
1442 >    }}
1443  
1444      /**
1445       * thenAcceptBoth result completes exceptionally if either source cancelled
1446       */
1447 <    public void testThenAcceptBoth_sourceCancelled1() {
1447 >    public void testThenAcceptBoth_sourceCancelled() {
1448          for (ExecutionMode m : ExecutionMode.values())
1449          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1450 <        for (Integer v1 : new Integer[] { 1, null }) {
1451 <
1452 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1453 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1436 <        final SubtractAction r = new SubtractAction();
1437 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1438 <
1439 <        assertTrue(f.cancel(mayInterruptIfRunning));
1440 <        checkIncomplete(h);
1441 <        g.complete(v1);
1442 <
1443 <        checkCompletedWithWrappedCancellationException(h);
1444 <        checkCancelled(f);
1445 <        assertEquals(0, r.invocationCount);
1446 <        checkCompletedNormally(g, v1);
1447 <        }
1448 <    }
1449 <
1450 <    public void testThenAcceptBoth_sourceCancelled2() {
1451 <        for (ExecutionMode m : ExecutionMode.values())
1452 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1453 <        for (Integer v1 : new Integer[] { 1, null }) {
1454 <
1455 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1456 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1457 <        final SubtractAction r = new SubtractAction();
1458 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1459 <
1460 <        assertTrue(g.cancel(mayInterruptIfRunning));
1461 <        checkIncomplete(h);
1462 <        f.complete(v1);
1463 <
1464 <        checkCompletedWithWrappedCancellationException(h);
1465 <        checkCancelled(g);
1466 <        assertEquals(0, r.invocationCount);
1467 <        checkCompletedNormally(f, v1);
1468 <        }
1469 <    }
1470 <
1471 <    public void testThenAcceptBoth_sourceCancelled3() {
1472 <        for (ExecutionMode m : ExecutionMode.values())
1473 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1474 <        for (Integer v1 : new Integer[] { 1, null }) {
1475 <
1450 >        for (boolean createIncomplete : new boolean[] { true, false })
1451 >        for (boolean fFirst : new boolean[] { true, false })
1452 >        for (Integer v1 : new Integer[] { 1, null })
1453 >    {
1454          final CompletableFuture<Integer> f = new CompletableFuture<>();
1455          final CompletableFuture<Integer> g = new CompletableFuture<>();
1456          final SubtractAction r = new SubtractAction();
1457  
1458 <        assertTrue(g.cancel(mayInterruptIfRunning));
1459 <        f.complete(v1);
1458 >        (fFirst ? f : g).complete(v1);
1459 >        if (!createIncomplete)
1460 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1461          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1462 <
1463 <        checkCompletedWithWrappedCancellationException(h);
1464 <        checkCancelled(g);
1486 <        assertEquals(0, r.invocationCount);
1487 <        checkCompletedNormally(f, v1);
1462 >        if (createIncomplete) {
1463 >            checkIncomplete(h);
1464 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1465          }
1489 –    }
1490 –
1491 –    public void testThenAcceptBoth_sourceCancelled4() {
1492 –        for (ExecutionMode m : ExecutionMode.values())
1493 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1494 –        for (Integer v1 : new Integer[] { 1, null }) {
1495 –
1496 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1497 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1498 –        final SubtractAction r = new SubtractAction();
1499 –
1500 –        assertTrue(f.cancel(mayInterruptIfRunning));
1501 –        g.complete(v1);
1502 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1466  
1467          checkCompletedWithWrappedCancellationException(h);
1468 <        checkCancelled(f);
1468 >        checkCancelled(!fFirst ? f : g);
1469          assertEquals(0, r.invocationCount);
1470 <        checkCompletedNormally(g, v1);
1471 <        }
1509 <    }
1470 >        checkCompletedNormally(fFirst ? f : g, v1);
1471 >    }}
1472  
1473      /**
1474       * runAfterBoth result completes normally after normal
# Line 1515 | Line 1477 | public class CompletableFutureTest exten
1477      public void testRunAfterBoth_normalCompletion1() {
1478          for (ExecutionMode m : ExecutionMode.values())
1479          for (Integer v1 : new Integer[] { 1, null })
1480 <        for (Integer v2 : new Integer[] { 2, null }) {
1481 <
1480 >        for (Integer v2 : new Integer[] { 2, null })
1481 >    {
1482          final CompletableFuture<Integer> f = new CompletableFuture<>();
1483          final CompletableFuture<Integer> g = new CompletableFuture<>();
1484          final Noop r = new Noop();
# Line 1531 | Line 1493 | public class CompletableFutureTest exten
1493          assertEquals(1, r.invocationCount);
1494          checkCompletedNormally(f, v1);
1495          checkCompletedNormally(g, v2);
1496 <        }
1535 <    }
1496 >    }}
1497  
1498      public void testRunAfterBoth_normalCompletion2() {
1499          for (ExecutionMode m : ExecutionMode.values())
1500          for (Integer v1 : new Integer[] { 1, null })
1501 <        for (Integer v2 : new Integer[] { 2, null }) {
1502 <
1501 >        for (Integer v2 : new Integer[] { 2, null })
1502 >    {
1503          final CompletableFuture<Integer> f = new CompletableFuture<>();
1504          final CompletableFuture<Integer> g = new CompletableFuture<>();
1505          final Noop r = new Noop();
# Line 1553 | Line 1514 | public class CompletableFutureTest exten
1514          assertEquals(1, r.invocationCount);
1515          checkCompletedNormally(f, v1);
1516          checkCompletedNormally(g, v2);
1517 <        }
1557 <    }
1517 >    }}
1518  
1519      public void testRunAfterBoth_normalCompletion3() {
1520          for (ExecutionMode m : ExecutionMode.values())
1521          for (Integer v1 : new Integer[] { 1, null })
1522 <        for (Integer v2 : new Integer[] { 2, null }) {
1523 <
1522 >        for (Integer v2 : new Integer[] { 2, null })
1523 >    {
1524          final CompletableFuture<Integer> f = new CompletableFuture<>();
1525          final CompletableFuture<Integer> g = new CompletableFuture<>();
1526          final Noop r = new Noop();
# Line 1573 | Line 1533 | public class CompletableFutureTest exten
1533          assertEquals(1, r.invocationCount);
1534          checkCompletedNormally(f, v1);
1535          checkCompletedNormally(g, v2);
1536 <        }
1577 <    }
1536 >    }}
1537  
1538      public void testRunAfterBoth_normalCompletion4() {
1539          for (ExecutionMode m : ExecutionMode.values())
1540          for (Integer v1 : new Integer[] { 1, null })
1541 <        for (Integer v2 : new Integer[] { 2, null }) {
1542 <
1541 >        for (Integer v2 : new Integer[] { 2, null })
1542 >    {
1543          final CompletableFuture<Integer> f = new CompletableFuture<>();
1544          final CompletableFuture<Integer> g = new CompletableFuture<>();
1545          final Noop r = new Noop();
# Line 1593 | Line 1552 | public class CompletableFutureTest exten
1552          assertEquals(1, r.invocationCount);
1553          checkCompletedNormally(f, v1);
1554          checkCompletedNormally(g, v2);
1555 <        }
1597 <    }
1555 >    }}
1556  
1557      /**
1558       * runAfterBoth result completes exceptionally after exceptional
# Line 1602 | Line 1560 | public class CompletableFutureTest exten
1560       */
1561      public void testRunAfterBoth_exceptionalCompletion1() {
1562          for (ExecutionMode m : ExecutionMode.values())
1563 <        for (Integer v1 : new Integer[] { 1, null }) {
1564 <
1563 >        for (Integer v1 : new Integer[] { 1, null })
1564 >    {
1565          final CompletableFuture<Integer> f = new CompletableFuture<>();
1566          final CompletableFuture<Integer> g = new CompletableFuture<>();
1567          final Noop r = new Noop();
# Line 1618 | Line 1576 | public class CompletableFutureTest exten
1576          checkCompletedWithWrappedCFException(f, ex);
1577          assertEquals(0, r.invocationCount);
1578          checkCompletedNormally(g, v1);
1579 <        }
1622 <    }
1579 >    }}
1580  
1581      public void testRunAfterBoth_exceptionalCompletion2() {
1582          for (ExecutionMode m : ExecutionMode.values())
1583 <        for (Integer v1 : new Integer[] { 1, null }) {
1584 <
1583 >        for (Integer v1 : new Integer[] { 1, null })
1584 >    {
1585          final CompletableFuture<Integer> f = new CompletableFuture<>();
1586          final CompletableFuture<Integer> g = new CompletableFuture<>();
1587          final Noop r = new Noop();
# Line 1639 | Line 1596 | public class CompletableFutureTest exten
1596          checkCompletedWithWrappedCFException(g, ex);
1597          assertEquals(0, r.invocationCount);
1598          checkCompletedNormally(f, v1);
1599 <        }
1643 <    }
1599 >    }}
1600  
1601      public void testRunAfterBoth_exceptionalCompletion3() {
1602          for (ExecutionMode m : ExecutionMode.values())
1603 <        for (Integer v1 : new Integer[] { 1, null }) {
1604 <
1603 >        for (Integer v1 : new Integer[] { 1, null })
1604 >    {
1605          final CompletableFuture<Integer> f = new CompletableFuture<>();
1606          final CompletableFuture<Integer> g = new CompletableFuture<>();
1607          final Noop r = new Noop();
# Line 1659 | Line 1615 | public class CompletableFutureTest exten
1615          checkCompletedWithWrappedCFException(g, ex);
1616          assertEquals(0, r.invocationCount);
1617          checkCompletedNormally(f, v1);
1618 <        }
1663 <    }
1618 >    }}
1619  
1620      public void testRunAfterBoth_exceptionalCompletion4() {
1621          for (ExecutionMode m : ExecutionMode.values())
1622 <        for (Integer v1 : new Integer[] { 1, null }) {
1623 <
1622 >        for (Integer v1 : new Integer[] { 1, null })
1623 >    {
1624          final CompletableFuture<Integer> f = new CompletableFuture<>();
1625          final CompletableFuture<Integer> g = new CompletableFuture<>();
1626          final Noop r = new Noop();
# Line 1679 | Line 1634 | public class CompletableFutureTest exten
1634          checkCompletedWithWrappedCFException(f, ex);
1635          assertEquals(0, r.invocationCount);
1636          checkCompletedNormally(g, v1);
1637 <        }
1683 <    }
1637 >    }}
1638  
1639      /**
1640       * runAfterBoth result completes exceptionally if action does
# Line 1688 | Line 1642 | public class CompletableFutureTest exten
1642      public void testRunAfterBoth_actionFailed1() {
1643          for (ExecutionMode m : ExecutionMode.values())
1644          for (Integer v1 : new Integer[] { 1, null })
1645 <        for (Integer v2 : new Integer[] { 2, null }) {
1646 <
1645 >        for (Integer v2 : new Integer[] { 2, null })
1646 >    {
1647          final CompletableFuture<Integer> f = new CompletableFuture<>();
1648          final CompletableFuture<Integer> g = new CompletableFuture<>();
1649 <        final FailingNoop r = new FailingNoop();
1649 >        final FailingRunnable r = new FailingRunnable();
1650          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1651  
1652          f.complete(v1);
# Line 1702 | Line 1656 | public class CompletableFutureTest exten
1656          checkCompletedWithWrappedCFException(h);
1657          checkCompletedNormally(f, v1);
1658          checkCompletedNormally(g, v2);
1659 <        }
1706 <    }
1659 >    }}
1660  
1661      public void testRunAfterBoth_actionFailed2() {
1662          for (ExecutionMode m : ExecutionMode.values())
1663          for (Integer v1 : new Integer[] { 1, null })
1664 <        for (Integer v2 : new Integer[] { 2, null }) {
1665 <
1664 >        for (Integer v2 : new Integer[] { 2, null })
1665 >    {
1666          final CompletableFuture<Integer> f = new CompletableFuture<>();
1667          final CompletableFuture<Integer> g = new CompletableFuture<>();
1668 <        final FailingNoop r = new FailingNoop();
1668 >        final FailingRunnable r = new FailingRunnable();
1669          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1670  
1671          g.complete(v2);
# Line 1722 | Line 1675 | public class CompletableFutureTest exten
1675          checkCompletedWithWrappedCFException(h);
1676          checkCompletedNormally(f, v1);
1677          checkCompletedNormally(g, v2);
1678 <        }
1726 <    }
1678 >    }}
1679  
1680      /**
1681       * runAfterBoth result completes exceptionally if either source cancelled
# Line 1731 | Line 1683 | public class CompletableFutureTest exten
1683      public void testRunAfterBoth_sourceCancelled1() {
1684          for (ExecutionMode m : ExecutionMode.values())
1685          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1686 <        for (Integer v1 : new Integer[] { 1, null }) {
1687 <
1686 >        for (Integer v1 : new Integer[] { 1, null })
1687 >    {
1688          final CompletableFuture<Integer> f = new CompletableFuture<>();
1689          final CompletableFuture<Integer> g = new CompletableFuture<>();
1690          final Noop r = new Noop();
# Line 1746 | Line 1698 | public class CompletableFutureTest exten
1698          checkCancelled(f);
1699          assertEquals(0, r.invocationCount);
1700          checkCompletedNormally(g, v1);
1701 <        }
1750 <    }
1701 >    }}
1702  
1703      public void testRunAfterBoth_sourceCancelled2() {
1704          for (ExecutionMode m : ExecutionMode.values())
1705          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1706 <        for (Integer v1 : new Integer[] { 1, null }) {
1707 <
1706 >        for (Integer v1 : new Integer[] { 1, null })
1707 >    {
1708          final CompletableFuture<Integer> f = new CompletableFuture<>();
1709          final CompletableFuture<Integer> g = new CompletableFuture<>();
1710          final Noop r = new Noop();
# Line 1767 | Line 1718 | public class CompletableFutureTest exten
1718          checkCancelled(g);
1719          assertEquals(0, r.invocationCount);
1720          checkCompletedNormally(f, v1);
1721 <        }
1771 <    }
1721 >    }}
1722  
1723      public void testRunAfterBoth_sourceCancelled3() {
1724          for (ExecutionMode m : ExecutionMode.values())
1725          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1726 <        for (Integer v1 : new Integer[] { 1, null }) {
1727 <
1726 >        for (Integer v1 : new Integer[] { 1, null })
1727 >    {
1728          final CompletableFuture<Integer> f = new CompletableFuture<>();
1729          final CompletableFuture<Integer> g = new CompletableFuture<>();
1730          final Noop r = new Noop();
# Line 1787 | Line 1737 | public class CompletableFutureTest exten
1737          checkCancelled(g);
1738          assertEquals(0, r.invocationCount);
1739          checkCompletedNormally(f, v1);
1740 <        }
1791 <    }
1740 >    }}
1741  
1742      public void testRunAfterBoth_sourceCancelled4() {
1743          for (ExecutionMode m : ExecutionMode.values())
1744          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1745 <        for (Integer v1 : new Integer[] { 1, null }) {
1746 <
1745 >        for (Integer v1 : new Integer[] { 1, null })
1746 >    {
1747          final CompletableFuture<Integer> f = new CompletableFuture<>();
1748          final CompletableFuture<Integer> g = new CompletableFuture<>();
1749          final Noop r = new Noop();
# Line 1807 | Line 1756 | public class CompletableFutureTest exten
1756          checkCancelled(f);
1757          assertEquals(0, r.invocationCount);
1758          checkCompletedNormally(g, v1);
1759 <        }
1811 <    }
1759 >    }}
1760  
1761      /**
1762       * applyToEither result completes normally after normal completion
# Line 1817 | Line 1765 | public class CompletableFutureTest exten
1765      public void testApplyToEither_normalCompletion1() {
1766          for (ExecutionMode m : ExecutionMode.values())
1767          for (Integer v1 : new Integer[] { 1, null })
1768 <        for (Integer v2 : new Integer[] { 2, null }) {
1769 <
1768 >        for (Integer v2 : new Integer[] { 2, null })
1769 >    {
1770          final CompletableFuture<Integer> f = new CompletableFuture<>();
1771          final CompletableFuture<Integer> g = new CompletableFuture<>();
1772          final IncFunction r = new IncFunction();
# Line 1831 | Line 1779 | public class CompletableFutureTest exten
1779          checkCompletedNormally(f, v1);
1780          checkCompletedNormally(g, v2);
1781          checkCompletedNormally(h, inc(v1));
1782 <        }
1835 <    }
1782 >    }}
1783  
1784      public void testApplyToEither_normalCompletion2() {
1785          for (ExecutionMode m : ExecutionMode.values())
1786          for (Integer v1 : new Integer[] { 1, null })
1787 <        for (Integer v2 : new Integer[] { 2, null }) {
1788 <
1787 >        for (Integer v2 : new Integer[] { 2, null })
1788 >    {
1789          final CompletableFuture<Integer> f = new CompletableFuture<>();
1790          final CompletableFuture<Integer> g = new CompletableFuture<>();
1791          final IncFunction r = new IncFunction();
# Line 1851 | Line 1798 | public class CompletableFutureTest exten
1798          checkCompletedNormally(f, v1);
1799          checkCompletedNormally(g, v2);
1800          checkCompletedNormally(h, inc(v2));
1801 <        }
1802 <    }
1801 >        }}
1802 >
1803      public void testApplyToEither_normalCompletion3() {
1804          for (ExecutionMode m : ExecutionMode.values())
1805          for (Integer v1 : new Integer[] { 1, null })
1806 <        for (Integer v2 : new Integer[] { 2, null }) {
1807 <
1806 >        for (Integer v2 : new Integer[] { 2, null })
1807 >    {
1808          final CompletableFuture<Integer> f = new CompletableFuture<>();
1809          final CompletableFuture<Integer> g = new CompletableFuture<>();
1810          final IncFunction r = new IncFunction();
# Line 1873 | Line 1820 | public class CompletableFutureTest exten
1820          assertTrue(Objects.equals(h.join(), inc(v1)) ||
1821                     Objects.equals(h.join(), inc(v2)));
1822          assertEquals(1, r.invocationCount);
1823 <        }
1877 <    }
1823 >    }}
1824  
1825      /**
1826       * applyToEither result completes exceptionally after exceptional
# Line 1882 | Line 1828 | public class CompletableFutureTest exten
1828       */
1829      public void testApplyToEither_exceptionalCompletion1() {
1830          for (ExecutionMode m : ExecutionMode.values())
1831 <        for (Integer v1 : new Integer[] { 1, null }) {
1832 <
1831 >        for (Integer v1 : new Integer[] { 1, null })
1832 >    {
1833          final CompletableFuture<Integer> f = new CompletableFuture<>();
1834          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835          final IncFunction r = new IncFunction();
# Line 1898 | Line 1844 | public class CompletableFutureTest exten
1844          checkCompletedNormally(g, v1);
1845          checkCompletedWithWrappedCFException(f, ex);
1846          checkCompletedWithWrappedCFException(h, ex);
1847 <        }
1902 <    }
1847 >    }}
1848  
1849      public void testApplyToEither_exceptionalCompletion2() {
1850          for (ExecutionMode m : ExecutionMode.values())
1851 <        for (Integer v1 : new Integer[] { 1, null }) {
1852 <
1851 >        for (Integer v1 : new Integer[] { 1, null })
1852 >    {
1853          final CompletableFuture<Integer> f = new CompletableFuture<>();
1854          final CompletableFuture<Integer> g = new CompletableFuture<>();
1855          final IncFunction r = new IncFunction();
# Line 1919 | Line 1864 | public class CompletableFutureTest exten
1864          checkCompletedNormally(f, v1);
1865          checkCompletedWithWrappedCFException(g, ex);
1866          checkCompletedWithWrappedCFException(h, ex);
1867 <        }
1923 <    }
1867 >    }}
1868  
1869      public void testApplyToEither_exceptionalCompletion3() {
1870          for (ExecutionMode m : ExecutionMode.values())
1871 <        for (Integer v1 : new Integer[] { 1, null }) {
1872 <
1871 >        for (Integer v1 : new Integer[] { 1, null })
1872 >    {
1873          final CompletableFuture<Integer> f = new CompletableFuture<>();
1874          final CompletableFuture<Integer> g = new CompletableFuture<>();
1875          final IncFunction r = new IncFunction();
# Line 1938 | Line 1882 | public class CompletableFutureTest exten
1882          // unspecified behavior
1883          Integer v;
1884          try {
1885 <            assertEquals(h.join(), inc(v1));
1885 >            assertEquals(inc(v1), h.join());
1886              assertEquals(1, r.invocationCount);
1887          } catch (CompletionException ok) {
1888              checkCompletedWithWrappedCFException(h, ex);
# Line 1947 | Line 1891 | public class CompletableFutureTest exten
1891  
1892          checkCompletedWithWrappedCFException(g, ex);
1893          checkCompletedNormally(f, v1);
1894 <        }
1951 <    }
1894 >    }}
1895  
1896      public void testApplyToEither_exceptionalCompletion4() {
1897          for (ExecutionMode m : ExecutionMode.values())
1898 <        for (Integer v1 : new Integer[] { 1, null }) {
1899 <
1898 >        for (Integer v1 : new Integer[] { 1, null })
1899 >    {
1900          final CompletableFuture<Integer> f = new CompletableFuture<>();
1901          final CompletableFuture<Integer> g = new CompletableFuture<>();
1902          final IncFunction r = new IncFunction();
# Line 1966 | Line 1909 | public class CompletableFutureTest exten
1909          // unspecified behavior
1910          Integer v;
1911          try {
1912 <            assertEquals(h.join(), inc(v1));
1912 >            assertEquals(inc(v1), h.join());
1913              assertEquals(1, r.invocationCount);
1914          } catch (CompletionException ok) {
1915              checkCompletedWithWrappedCFException(h, ex);
# Line 1975 | Line 1918 | public class CompletableFutureTest exten
1918  
1919          checkCompletedWithWrappedCFException(f, ex);
1920          checkCompletedNormally(g, v1);
1921 <        }
1979 <    }
1921 >    }}
1922  
1923      /**
1924       * applyToEither result completes exceptionally if action does
# Line 1984 | Line 1926 | public class CompletableFutureTest exten
1926      public void testApplyToEither_actionFailed1() {
1927          for (ExecutionMode m : ExecutionMode.values())
1928          for (Integer v1 : new Integer[] { 1, null })
1929 <        for (Integer v2 : new Integer[] { 2, null }) {
1930 <
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 FailingFunction r = new FailingFunction();
# Line 1996 | Line 1938 | public class CompletableFutureTest exten
1938          g.complete(v2);
1939          checkCompletedNormally(f, v1);
1940          checkCompletedNormally(g, v2);
1941 <        }
2000 <    }
1941 >    }}
1942  
1943      public void testApplyToEither_actionFailed2() {
1944          for (ExecutionMode m : ExecutionMode.values())
1945          for (Integer v1 : new Integer[] { 1, null })
1946 <        for (Integer v2 : new Integer[] { 2, null }) {
1947 <
1946 >        for (Integer v2 : new Integer[] { 2, null })
1947 >    {
1948          final CompletableFuture<Integer> f = new CompletableFuture<>();
1949          final CompletableFuture<Integer> g = new CompletableFuture<>();
1950          final FailingFunction r = new FailingFunction();
# Line 2014 | Line 1955 | public class CompletableFutureTest exten
1955          f.complete(v1);
1956          checkCompletedNormally(f, v1);
1957          checkCompletedNormally(g, v2);
1958 <        }
2018 <    }
1958 >    }}
1959  
1960      /**
1961       * applyToEither result completes exceptionally if either source cancelled
# Line 2023 | Line 1963 | public class CompletableFutureTest exten
1963      public void testApplyToEither_sourceCancelled1() {
1964          for (ExecutionMode m : ExecutionMode.values())
1965          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1966 <        for (Integer v1 : new Integer[] { 1, null }) {
1967 <
1966 >        for (Integer v1 : new Integer[] { 1, null })
1967 >    {
1968          final CompletableFuture<Integer> f = new CompletableFuture<>();
1969          final CompletableFuture<Integer> g = new CompletableFuture<>();
1970          final IncFunction r = new IncFunction();
# Line 2038 | Line 1978 | public class CompletableFutureTest exten
1978          assertEquals(0, r.invocationCount);
1979          checkCompletedNormally(g, v1);
1980          checkCompletedWithWrappedCancellationException(h);
1981 <        }
2042 <    }
1981 >    }}
1982  
1983      public void testApplyToEither_sourceCancelled2() {
1984          for (ExecutionMode m : ExecutionMode.values())
1985          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1986 <        for (Integer v1 : new Integer[] { 1, null }) {
1987 <
1986 >        for (Integer v1 : new Integer[] { 1, null })
1987 >    {
1988          final CompletableFuture<Integer> f = new CompletableFuture<>();
1989          final CompletableFuture<Integer> g = new CompletableFuture<>();
1990          final IncFunction r = new IncFunction();
# Line 2059 | Line 1998 | public class CompletableFutureTest exten
1998          assertEquals(0, r.invocationCount);
1999          checkCompletedNormally(f, v1);
2000          checkCompletedWithWrappedCancellationException(h);
2001 <        }
2063 <    }
2001 >    }}
2002  
2003      public void testApplyToEither_sourceCancelled3() {
2004          for (ExecutionMode m : ExecutionMode.values())
2005          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2006 <        for (Integer v1 : new Integer[] { 1, null }) {
2007 <
2006 >        for (Integer v1 : new Integer[] { 1, null })
2007 >    {
2008          final CompletableFuture<Integer> f = new CompletableFuture<>();
2009          final CompletableFuture<Integer> g = new CompletableFuture<>();
2010          final IncFunction r = new IncFunction();
# Line 2078 | Line 2016 | public class CompletableFutureTest exten
2016          // unspecified behavior
2017          Integer v;
2018          try {
2019 <            assertEquals(h.join(), inc(v1));
2019 >            assertEquals(inc(v1), h.join());
2020              assertEquals(1, r.invocationCount);
2021          } catch (CompletionException ok) {
2022              checkCompletedWithWrappedCancellationException(h);
# Line 2087 | Line 2025 | public class CompletableFutureTest exten
2025  
2026          checkCancelled(g);
2027          checkCompletedNormally(f, v1);
2028 <        }
2091 <    }
2028 >    }}
2029  
2030      public void testApplyToEither_sourceCancelled4() {
2031          for (ExecutionMode m : ExecutionMode.values())
2032          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2033 <        for (Integer v1 : new Integer[] { 1, null }) {
2034 <
2033 >        for (Integer v1 : new Integer[] { 1, null })
2034 >    {
2035          final CompletableFuture<Integer> f = new CompletableFuture<>();
2036          final CompletableFuture<Integer> g = new CompletableFuture<>();
2037          final IncFunction r = new IncFunction();
# Line 2106 | Line 2043 | public class CompletableFutureTest exten
2043          // unspecified behavior
2044          Integer v;
2045          try {
2046 <            assertEquals(h.join(), inc(v1));
2046 >            assertEquals(inc(v1), h.join());
2047              assertEquals(1, r.invocationCount);
2048          } catch (CompletionException ok) {
2049              checkCompletedWithWrappedCancellationException(h);
# Line 2115 | Line 2052 | public class CompletableFutureTest exten
2052  
2053          checkCancelled(f);
2054          checkCompletedNormally(g, v1);
2055 <        }
2119 <    }
2055 >    }}
2056  
2057      /**
2058       * acceptEither result completes normally after normal completion
# Line 2125 | Line 2061 | public class CompletableFutureTest exten
2061      public void testAcceptEither_normalCompletion1() {
2062          for (ExecutionMode m : ExecutionMode.values())
2063          for (Integer v1 : new Integer[] { 1, null })
2064 <        for (Integer v2 : new Integer[] { 2, null }) {
2065 <
2064 >        for (Integer v2 : new Integer[] { 2, null })
2065 >    {
2066          final CompletableFuture<Integer> f = new CompletableFuture<>();
2067          final CompletableFuture<Integer> g = new CompletableFuture<>();
2068          final IncAction r = new IncAction();
# Line 2134 | Line 2070 | public class CompletableFutureTest exten
2070  
2071          f.complete(v1);
2072          checkCompletedNormally(h, null);
2073 <        assertEquals(r.value, inc(v1));
2073 >        assertEquals(inc(v1), r.value);
2074          g.complete(v2);
2075  
2076          checkCompletedNormally(f, v1);
2077          checkCompletedNormally(g, v2);
2078          checkCompletedNormally(h, null);
2079 <        }
2144 <    }
2079 >    }}
2080  
2081      public void testAcceptEither_normalCompletion2() {
2082          for (ExecutionMode m : ExecutionMode.values())
2083          for (Integer v1 : new Integer[] { 1, null })
2084 <        for (Integer v2 : new Integer[] { 2, null }) {
2085 <
2084 >        for (Integer v2 : new Integer[] { 2, null })
2085 >    {
2086          final CompletableFuture<Integer> f = new CompletableFuture<>();
2087          final CompletableFuture<Integer> g = new CompletableFuture<>();
2088          final IncAction r = new IncAction();
# Line 2155 | Line 2090 | public class CompletableFutureTest exten
2090  
2091          g.complete(v2);
2092          checkCompletedNormally(h, null);
2093 <        assertEquals(r.value, inc(v2));
2093 >        assertEquals(inc(v2), r.value);
2094          f.complete(v1);
2095  
2096          checkCompletedNormally(f, v1);
2097          checkCompletedNormally(g, v2);
2098          checkCompletedNormally(h, null);
2099 <        }
2100 <    }
2099 >    }}
2100 >
2101      public void testAcceptEither_normalCompletion3() {
2102          for (ExecutionMode m : ExecutionMode.values())
2103          for (Integer v1 : new Integer[] { 1, null })
2104 <        for (Integer v2 : new Integer[] { 2, null }) {
2105 <
2104 >        for (Integer v2 : new Integer[] { 2, null })
2105 >    {
2106          final CompletableFuture<Integer> f = new CompletableFuture<>();
2107          final CompletableFuture<Integer> g = new CompletableFuture<>();
2108          final IncAction r = new IncAction();
# Line 2183 | Line 2118 | public class CompletableFutureTest exten
2118          // unspecified behavior
2119          assertTrue(Objects.equals(r.value, inc(v1)) ||
2120                     Objects.equals(r.value, inc(v2)));
2121 <        }
2187 <    }
2121 >    }}
2122  
2123      /**
2124       * acceptEither result completes exceptionally after exceptional
# Line 2192 | Line 2126 | public class CompletableFutureTest exten
2126       */
2127      public void testAcceptEither_exceptionalCompletion1() {
2128          for (ExecutionMode m : ExecutionMode.values())
2129 <        for (Integer v1 : new Integer[] { 1, null }) {
2130 <
2129 >        for (Integer v1 : new Integer[] { 1, null })
2130 >    {
2131          final CompletableFuture<Integer> f = new CompletableFuture<>();
2132          final CompletableFuture<Integer> g = new CompletableFuture<>();
2133          final IncAction r = new IncAction();
# Line 2208 | Line 2142 | public class CompletableFutureTest exten
2142          checkCompletedNormally(g, v1);
2143          checkCompletedWithWrappedCFException(f, ex);
2144          checkCompletedWithWrappedCFException(h, ex);
2145 <        }
2212 <    }
2145 >    }}
2146  
2147      public void testAcceptEither_exceptionalCompletion2() {
2148          for (ExecutionMode m : ExecutionMode.values())
2149 <        for (Integer v1 : new Integer[] { 1, null }) {
2150 <
2149 >        for (Integer v1 : new Integer[] { 1, null })
2150 >    {
2151          final CompletableFuture<Integer> f = new CompletableFuture<>();
2152          final CompletableFuture<Integer> g = new CompletableFuture<>();
2153          final IncAction r = new IncAction();
# Line 2229 | Line 2162 | public class CompletableFutureTest exten
2162          checkCompletedNormally(f, v1);
2163          checkCompletedWithWrappedCFException(g, ex);
2164          checkCompletedWithWrappedCFException(h, ex);
2165 <        }
2233 <    }
2165 >    }}
2166  
2167      public void testAcceptEither_exceptionalCompletion3() {
2168          for (ExecutionMode m : ExecutionMode.values())
2169 <        for (Integer v1 : new Integer[] { 1, null }) {
2170 <
2169 >        for (Integer v1 : new Integer[] { 1, null })
2170 >    {
2171          final CompletableFuture<Integer> f = new CompletableFuture<>();
2172          final CompletableFuture<Integer> g = new CompletableFuture<>();
2173          final IncAction r = new IncAction();
# Line 2248 | Line 2180 | public class CompletableFutureTest exten
2180          // unspecified behavior
2181          Integer v;
2182          try {
2183 <            assertEquals(h.join(), null);
2183 >            assertNull(h.join());
2184              assertEquals(1, r.invocationCount);
2185              assertEquals(inc(v1), r.value);
2186          } catch (CompletionException ok) {
# Line 2258 | Line 2190 | public class CompletableFutureTest exten
2190  
2191          checkCompletedWithWrappedCFException(g, ex);
2192          checkCompletedNormally(f, v1);
2193 <        }
2262 <    }
2193 >    }}
2194  
2195      public void testAcceptEither_exceptionalCompletion4() {
2196          for (ExecutionMode m : ExecutionMode.values())
2197 <        for (Integer v1 : new Integer[] { 1, null }) {
2198 <
2197 >        for (Integer v1 : new Integer[] { 1, null })
2198 >    {
2199          final CompletableFuture<Integer> f = new CompletableFuture<>();
2200          final CompletableFuture<Integer> g = new CompletableFuture<>();
2201          final IncAction r = new IncAction();
# Line 2277 | Line 2208 | public class CompletableFutureTest exten
2208          // unspecified behavior
2209          Integer v;
2210          try {
2211 <            assertEquals(h.join(), null);
2211 >            assertNull(h.join());
2212              assertEquals(1, r.invocationCount);
2213              assertEquals(inc(v1), r.value);
2214          } catch (CompletionException ok) {
# Line 2287 | Line 2218 | public class CompletableFutureTest exten
2218  
2219          checkCompletedWithWrappedCFException(f, ex);
2220          checkCompletedNormally(g, v1);
2221 <        }
2291 <    }
2221 >    }}
2222  
2223      /**
2224       * acceptEither result completes exceptionally if action does
# Line 2296 | Line 2226 | public class CompletableFutureTest exten
2226      public void testAcceptEither_actionFailed1() {
2227          for (ExecutionMode m : ExecutionMode.values())
2228          for (Integer v1 : new Integer[] { 1, null })
2229 <        for (Integer v2 : new Integer[] { 2, null }) {
2230 <
2229 >        for (Integer v2 : new Integer[] { 2, null })
2230 >    {
2231          final CompletableFuture<Integer> f = new CompletableFuture<>();
2232          final CompletableFuture<Integer> g = new CompletableFuture<>();
2233          final FailingConsumer r = new FailingConsumer();
# Line 2308 | Line 2238 | public class CompletableFutureTest exten
2238          g.complete(v2);
2239          checkCompletedNormally(f, v1);
2240          checkCompletedNormally(g, v2);
2241 <        }
2312 <    }
2241 >    }}
2242  
2243      public void testAcceptEither_actionFailed2() {
2244          for (ExecutionMode m : ExecutionMode.values())
2245          for (Integer v1 : new Integer[] { 1, null })
2246 <        for (Integer v2 : new Integer[] { 2, null }) {
2247 <
2246 >        for (Integer v2 : new Integer[] { 2, null })
2247 >    {
2248          final CompletableFuture<Integer> f = new CompletableFuture<>();
2249          final CompletableFuture<Integer> g = new CompletableFuture<>();
2250          final FailingConsumer r = new FailingConsumer();
# Line 2326 | Line 2255 | public class CompletableFutureTest exten
2255          f.complete(v1);
2256          checkCompletedNormally(f, v1);
2257          checkCompletedNormally(g, v2);
2258 <        }
2330 <    }
2258 >    }}
2259  
2260      /**
2261       * acceptEither result completes exceptionally if either source cancelled
# Line 2335 | Line 2263 | public class CompletableFutureTest exten
2263      public void testAcceptEither_sourceCancelled1() {
2264          for (ExecutionMode m : ExecutionMode.values())
2265          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2266 <        for (Integer v1 : new Integer[] { 1, null }) {
2267 <
2266 >        for (Integer v1 : new Integer[] { 1, null })
2267 >    {
2268          final CompletableFuture<Integer> f = new CompletableFuture<>();
2269          final CompletableFuture<Integer> g = new CompletableFuture<>();
2270          final IncAction r = new IncAction();
# Line 2350 | Line 2278 | public class CompletableFutureTest exten
2278          assertEquals(0, r.invocationCount);
2279          checkCompletedNormally(g, v1);
2280          checkCompletedWithWrappedCancellationException(h);
2281 <        }
2354 <    }
2281 >    }}
2282  
2283      public void testAcceptEither_sourceCancelled2() {
2284          for (ExecutionMode m : ExecutionMode.values())
2285          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2286 <        for (Integer v1 : new Integer[] { 1, null }) {
2287 <
2286 >        for (Integer v1 : new Integer[] { 1, null })
2287 >    {
2288          final CompletableFuture<Integer> f = new CompletableFuture<>();
2289          final CompletableFuture<Integer> g = new CompletableFuture<>();
2290          final IncAction r = new IncAction();
# Line 2371 | Line 2298 | public class CompletableFutureTest exten
2298          assertEquals(0, r.invocationCount);
2299          checkCompletedNormally(f, v1);
2300          checkCompletedWithWrappedCancellationException(h);
2301 <        }
2375 <    }
2301 >    }}
2302  
2303      public void testAcceptEither_sourceCancelled3() {
2304          for (ExecutionMode m : ExecutionMode.values())
2305          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2306 <        for (Integer v1 : new Integer[] { 1, null }) {
2307 <
2306 >        for (Integer v1 : new Integer[] { 1, null })
2307 >    {
2308          final CompletableFuture<Integer> f = new CompletableFuture<>();
2309          final CompletableFuture<Integer> g = new CompletableFuture<>();
2310          final IncAction r = new IncAction();
# Line 2390 | Line 2316 | public class CompletableFutureTest exten
2316          // unspecified behavior
2317          Integer v;
2318          try {
2319 <            assertEquals(h.join(), null);
2319 >            assertNull(h.join());
2320              assertEquals(1, r.invocationCount);
2321              assertEquals(inc(v1), r.value);
2322          } catch (CompletionException ok) {
# Line 2400 | Line 2326 | public class CompletableFutureTest exten
2326  
2327          checkCancelled(g);
2328          checkCompletedNormally(f, v1);
2329 <        }
2404 <    }
2329 >    }}
2330  
2331      public void testAcceptEither_sourceCancelled4() {
2332          for (ExecutionMode m : ExecutionMode.values())
2333          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2334 <        for (Integer v1 : new Integer[] { 1, null }) {
2335 <
2334 >        for (Integer v1 : new Integer[] { 1, null })
2335 >    {
2336          final CompletableFuture<Integer> f = new CompletableFuture<>();
2337          final CompletableFuture<Integer> g = new CompletableFuture<>();
2338          final IncAction r = new IncAction();
# Line 2419 | Line 2344 | public class CompletableFutureTest exten
2344          // unspecified behavior
2345          Integer v;
2346          try {
2347 <            assertEquals(h.join(), null);
2347 >            assertNull(h.join());
2348              assertEquals(1, r.invocationCount);
2349              assertEquals(inc(v1), r.value);
2350          } catch (CompletionException ok) {
# Line 2429 | Line 2354 | public class CompletableFutureTest exten
2354  
2355          checkCancelled(f);
2356          checkCompletedNormally(g, v1);
2357 <        }
2433 <    }
2357 >    }}
2358  
2359      /**
2360       * runAfterEither result completes normally after normal completion
# Line 2439 | Line 2363 | public class CompletableFutureTest exten
2363      public void testRunAfterEither_normalCompletion1() {
2364          for (ExecutionMode m : ExecutionMode.values())
2365          for (Integer v1 : new Integer[] { 1, null })
2366 <        for (Integer v2 : new Integer[] { 2, null }) {
2367 <
2366 >        for (Integer v2 : new Integer[] { 2, null })
2367 >    {
2368          final CompletableFuture<Integer> f = new CompletableFuture<>();
2369          final CompletableFuture<Integer> g = new CompletableFuture<>();
2370          final Noop r = new Noop();
# Line 2455 | Line 2379 | public class CompletableFutureTest exten
2379          checkCompletedNormally(g, v2);
2380          checkCompletedNormally(h, null);
2381          assertEquals(1, r.invocationCount);
2382 <        }
2459 <    }
2382 >    }}
2383  
2384      public void testRunAfterEither_normalCompletion2() {
2385          for (ExecutionMode m : ExecutionMode.values())
2386          for (Integer v1 : new Integer[] { 1, null })
2387 <        for (Integer v2 : new Integer[] { 2, null }) {
2388 <
2387 >        for (Integer v2 : new Integer[] { 2, null })
2388 >    {
2389          final CompletableFuture<Integer> f = new CompletableFuture<>();
2390          final CompletableFuture<Integer> g = new CompletableFuture<>();
2391          final Noop r = new Noop();
# Line 2477 | Line 2400 | public class CompletableFutureTest exten
2400          checkCompletedNormally(g, v2);
2401          checkCompletedNormally(h, null);
2402          assertEquals(1, r.invocationCount);
2403 <        }
2404 <    }
2403 >        }}
2404 >
2405      public void testRunAfterEither_normalCompletion3() {
2406          for (ExecutionMode m : ExecutionMode.values())
2407          for (Integer v1 : new Integer[] { 1, null })
2408 <        for (Integer v2 : new Integer[] { 2, null }) {
2409 <
2408 >        for (Integer v2 : new Integer[] { 2, null })
2409 >    {
2410          final CompletableFuture<Integer> f = new CompletableFuture<>();
2411          final CompletableFuture<Integer> g = new CompletableFuture<>();
2412          final Noop r = new Noop();
# Line 2496 | Line 2419 | public class CompletableFutureTest exten
2419          checkCompletedNormally(f, v1);
2420          checkCompletedNormally(g, v2);
2421          assertEquals(1, r.invocationCount);
2422 <        }
2500 <    }
2422 >    }}
2423  
2424      /**
2425       * runAfterEither result completes exceptionally after exceptional
# Line 2505 | Line 2427 | public class CompletableFutureTest exten
2427       */
2428      public void testRunAfterEither_exceptionalCompletion1() {
2429          for (ExecutionMode m : ExecutionMode.values())
2430 <        for (Integer v1 : new Integer[] { 1, null }) {
2431 <
2430 >        for (Integer v1 : new Integer[] { 1, null })
2431 >    {
2432          final CompletableFuture<Integer> f = new CompletableFuture<>();
2433          final CompletableFuture<Integer> g = new CompletableFuture<>();
2434          final Noop r = new Noop();
# Line 2521 | Line 2443 | public class CompletableFutureTest exten
2443          checkCompletedNormally(g, v1);
2444          checkCompletedWithWrappedCFException(f, ex);
2445          checkCompletedWithWrappedCFException(h, ex);
2446 <        }
2525 <    }
2446 >    }}
2447  
2448      public void testRunAfterEither_exceptionalCompletion2() {
2449          for (ExecutionMode m : ExecutionMode.values())
2450 <        for (Integer v1 : new Integer[] { 1, null }) {
2451 <
2450 >        for (Integer v1 : new Integer[] { 1, null })
2451 >    {
2452          final CompletableFuture<Integer> f = new CompletableFuture<>();
2453          final CompletableFuture<Integer> g = new CompletableFuture<>();
2454          final Noop r = new Noop();
# Line 2542 | Line 2463 | public class CompletableFutureTest exten
2463          checkCompletedNormally(f, v1);
2464          checkCompletedWithWrappedCFException(g, ex);
2465          checkCompletedWithWrappedCFException(h, ex);
2466 <        }
2546 <    }
2466 >    }}
2467  
2468      public void testRunAfterEither_exceptionalCompletion3() {
2469          for (ExecutionMode m : ExecutionMode.values())
2470 <        for (Integer v1 : new Integer[] { 1, null }) {
2471 <
2470 >        for (Integer v1 : new Integer[] { 1, null })
2471 >    {
2472          final CompletableFuture<Integer> f = new CompletableFuture<>();
2473          final CompletableFuture<Integer> g = new CompletableFuture<>();
2474          final Noop r = new Noop();
# Line 2561 | Line 2481 | public class CompletableFutureTest exten
2481          // unspecified behavior
2482          Integer v;
2483          try {
2484 <            assertEquals(h.join(), null);
2484 >            assertNull(h.join());
2485              assertEquals(1, r.invocationCount);
2486          } catch (CompletionException ok) {
2487              checkCompletedWithWrappedCFException(h, ex);
# Line 2570 | Line 2490 | public class CompletableFutureTest exten
2490  
2491          checkCompletedWithWrappedCFException(g, ex);
2492          checkCompletedNormally(f, v1);
2493 <        }
2574 <    }
2493 >    }}
2494  
2495      public void testRunAfterEither_exceptionalCompletion4() {
2496          for (ExecutionMode m : ExecutionMode.values())
2497 <        for (Integer v1 : new Integer[] { 1, null }) {
2498 <
2497 >        for (Integer v1 : new Integer[] { 1, null })
2498 >    {
2499          final CompletableFuture<Integer> f = new CompletableFuture<>();
2500          final CompletableFuture<Integer> g = new CompletableFuture<>();
2501          final Noop r = new Noop();
# Line 2589 | Line 2508 | public class CompletableFutureTest exten
2508          // unspecified behavior
2509          Integer v;
2510          try {
2511 <            assertEquals(h.join(), null);
2511 >            assertNull(h.join());
2512              assertEquals(1, r.invocationCount);
2513          } catch (CompletionException ok) {
2514              checkCompletedWithWrappedCFException(h, ex);
# Line 2598 | Line 2517 | public class CompletableFutureTest exten
2517  
2518          checkCompletedWithWrappedCFException(f, ex);
2519          checkCompletedNormally(g, v1);
2520 <        }
2602 <    }
2520 >    }}
2521  
2522      /**
2523       * runAfterEither result completes exceptionally if action does
# Line 2607 | Line 2525 | public class CompletableFutureTest exten
2525      public void testRunAfterEither_actionFailed1() {
2526          for (ExecutionMode m : ExecutionMode.values())
2527          for (Integer v1 : new Integer[] { 1, null })
2528 <        for (Integer v2 : new Integer[] { 2, null }) {
2529 <
2528 >        for (Integer v2 : new Integer[] { 2, null })
2529 >    {
2530          final CompletableFuture<Integer> f = new CompletableFuture<>();
2531          final CompletableFuture<Integer> g = new CompletableFuture<>();
2532 <        final FailingNoop r = new FailingNoop();
2532 >        final FailingRunnable r = new FailingRunnable();
2533          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2534  
2535          f.complete(v1);
# Line 2619 | Line 2537 | public class CompletableFutureTest exten
2537          g.complete(v2);
2538          checkCompletedNormally(f, v1);
2539          checkCompletedNormally(g, v2);
2540 <        }
2623 <    }
2540 >    }}
2541  
2542      public void testRunAfterEither_actionFailed2() {
2543          for (ExecutionMode m : ExecutionMode.values())
2544          for (Integer v1 : new Integer[] { 1, null })
2545 <        for (Integer v2 : new Integer[] { 2, null }) {
2546 <
2545 >        for (Integer v2 : new Integer[] { 2, null })
2546 >    {
2547          final CompletableFuture<Integer> f = new CompletableFuture<>();
2548          final CompletableFuture<Integer> g = new CompletableFuture<>();
2549 <        final FailingNoop r = new FailingNoop();
2549 >        final FailingRunnable r = new FailingRunnable();
2550          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2551  
2552          g.complete(v2);
# Line 2637 | Line 2554 | public class CompletableFutureTest exten
2554          f.complete(v1);
2555          checkCompletedNormally(f, v1);
2556          checkCompletedNormally(g, v2);
2557 <        }
2641 <    }
2557 >    }}
2558  
2559      /**
2560       * runAfterEither result completes exceptionally if either source cancelled
# Line 2646 | Line 2562 | public class CompletableFutureTest exten
2562      public void testRunAfterEither_sourceCancelled1() {
2563          for (ExecutionMode m : ExecutionMode.values())
2564          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2565 <        for (Integer v1 : new Integer[] { 1, null }) {
2566 <
2565 >        for (Integer v1 : new Integer[] { 1, null })
2566 >    {
2567          final CompletableFuture<Integer> f = new CompletableFuture<>();
2568          final CompletableFuture<Integer> g = new CompletableFuture<>();
2569          final Noop r = new Noop();
# Line 2661 | Line 2577 | public class CompletableFutureTest exten
2577          assertEquals(0, r.invocationCount);
2578          checkCompletedNormally(g, v1);
2579          checkCompletedWithWrappedCancellationException(h);
2580 <        }
2665 <    }
2580 >    }}
2581  
2582      public void testRunAfterEither_sourceCancelled2() {
2583          for (ExecutionMode m : ExecutionMode.values())
2584          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2585 <        for (Integer v1 : new Integer[] { 1, null }) {
2586 <
2585 >        for (Integer v1 : new Integer[] { 1, null })
2586 >    {
2587          final CompletableFuture<Integer> f = new CompletableFuture<>();
2588          final CompletableFuture<Integer> g = new CompletableFuture<>();
2589          final Noop r = new Noop();
# Line 2682 | Line 2597 | public class CompletableFutureTest exten
2597          assertEquals(0, r.invocationCount);
2598          checkCompletedNormally(f, v1);
2599          checkCompletedWithWrappedCancellationException(h);
2600 <        }
2686 <    }
2600 >    }}
2601  
2602      public void testRunAfterEither_sourceCancelled3() {
2603          for (ExecutionMode m : ExecutionMode.values())
2604          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2605 <        for (Integer v1 : new Integer[] { 1, null }) {
2606 <
2605 >        for (Integer v1 : new Integer[] { 1, null })
2606 >    {
2607          final CompletableFuture<Integer> f = new CompletableFuture<>();
2608          final CompletableFuture<Integer> g = new CompletableFuture<>();
2609          final Noop r = new Noop();
# Line 2701 | Line 2615 | public class CompletableFutureTest exten
2615          // unspecified behavior
2616          Integer v;
2617          try {
2618 <            assertEquals(h.join(), null);
2618 >            assertNull(h.join());
2619              assertEquals(1, r.invocationCount);
2620          } catch (CompletionException ok) {
2621              checkCompletedWithWrappedCancellationException(h);
# Line 2710 | Line 2624 | public class CompletableFutureTest exten
2624  
2625          checkCancelled(g);
2626          checkCompletedNormally(f, v1);
2627 <        }
2714 <    }
2627 >    }}
2628  
2629      public void testRunAfterEither_sourceCancelled4() {
2630          for (ExecutionMode m : ExecutionMode.values())
2631          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2632 <        for (Integer v1 : new Integer[] { 1, null }) {
2633 <
2632 >        for (Integer v1 : new Integer[] { 1, null })
2633 >    {
2634          final CompletableFuture<Integer> f = new CompletableFuture<>();
2635          final CompletableFuture<Integer> g = new CompletableFuture<>();
2636          final Noop r = new Noop();
# Line 2729 | Line 2642 | public class CompletableFutureTest exten
2642          // unspecified behavior
2643          Integer v;
2644          try {
2645 <            assertEquals(h.join(), null);
2645 >            assertNull(h.join());
2646              assertEquals(1, r.invocationCount);
2647          } catch (CompletionException ok) {
2648              checkCompletedWithWrappedCancellationException(h);
# Line 2738 | Line 2651 | public class CompletableFutureTest exten
2651  
2652          checkCancelled(f);
2653          checkCompletedNormally(g, v1);
2654 <        }
2742 <    }
2654 >    }}
2655  
2656      /**
2657       * thenCompose result completes normally after normal completion of source
2658       */
2659 <    public void testThenCompose_normalCompletion1() {
2659 >    public void testThenCompose_normalCompletion() {
2660          for (ExecutionMode m : ExecutionMode.values())
2661 <        for (Integer v1 : new Integer[] { 1, null }) {
2662 <
2661 >        for (boolean createIncomplete : new boolean[] { true, false })
2662 >        for (Integer v1 : new Integer[] { 1, null })
2663 >    {
2664          final CompletableFuture<Integer> f = new CompletableFuture<>();
2665          final CompletableFutureInc r = new CompletableFutureInc();
2666 +        if (!createIncomplete) f.complete(v1);
2667          final CompletableFuture<Integer> g = f.thenCompose(r);
2668 <        f.complete(v1);
2755 <        checkCompletedNormally(g, inc(v1));
2756 <        checkCompletedNormally(f, v1);
2757 <        assertEquals(1, r.invocationCount);
2758 <        }
2759 <    }
2760 <
2761 <    public void testThenCompose_normalCompletion2() {
2762 <        for (ExecutionMode m : ExecutionMode.values())
2763 <        for (Integer v1 : new Integer[] { 1, null }) {
2668 >        if (createIncomplete) f.complete(v1);
2669  
2765 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2766 –        final CompletableFutureInc r = new CompletableFutureInc();
2767 –        f.complete(v1);
2768 –        final CompletableFuture<Integer> g = f.thenCompose(r);
2670          checkCompletedNormally(g, inc(v1));
2671          checkCompletedNormally(f, v1);
2672          assertEquals(1, r.invocationCount);
2673 <        }
2773 <    }
2673 >    }}
2674  
2675      /**
2676       * thenCompose result completes exceptionally after exceptional
2677       * completion of source
2678       */
2679 <    public void testThenCompose_exceptionalCompletion1() {
2680 <        for (ExecutionMode m : ExecutionMode.values()) {
2681 <
2679 >    public void testThenCompose_exceptionalCompletion() {
2680 >        for (ExecutionMode m : ExecutionMode.values())
2681 >        for (boolean createIncomplete : new boolean[] { true, false })
2682 >    {
2683          final CFException ex = new CFException();
2684          final CompletableFutureInc r = new CompletableFutureInc();
2685          final CompletableFuture<Integer> f = new CompletableFuture<>();
2686 +        if (!createIncomplete) f.completeExceptionally(ex);
2687          final CompletableFuture<Integer> g = f.thenCompose(r);
2688 <        f.completeExceptionally(ex);
2787 <        checkCompletedWithWrappedCFException(g, ex);
2788 <        checkCompletedWithWrappedCFException(f, ex);
2789 <        }
2790 <    }
2791 <
2792 <    public void testThenCompose_exceptionalCompletion2() {
2793 <        for (ExecutionMode m : ExecutionMode.values()) {
2688 >        if (createIncomplete) f.completeExceptionally(ex);
2689  
2795 –        final CFException ex = new CFException();
2796 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2797 –        f.completeExceptionally(ex);
2798 –        final CompletableFutureInc r = new CompletableFutureInc();
2799 –        final CompletableFuture<Integer> g = f.thenCompose(r);
2690          checkCompletedWithWrappedCFException(g, ex);
2691          checkCompletedWithWrappedCFException(f, ex);
2692 <        }
2693 <    }
2692 >        assertEquals(0, r.invocationCount);
2693 >    }}
2694  
2695      /**
2696       * thenCompose result completes exceptionally if action does
2697       */
2698 <    public void testThenCompose_actionFailed1() {
2698 >    public void testThenCompose_actionFailed() {
2699          for (ExecutionMode m : ExecutionMode.values())
2700 <        for (Integer v1 : new Integer[] { 1, null }) {
2701 <
2700 >        for (boolean createIncomplete : new boolean[] { true, false })
2701 >        for (Integer v1 : new Integer[] { 1, null })
2702 >    {
2703          final CompletableFuture<Integer> f = new CompletableFuture<>();
2704          final FailingCompletableFutureFunction r
2705              = new FailingCompletableFutureFunction();
2706 +        if (!createIncomplete) f.complete(v1);
2707          final CompletableFuture<Integer> g = f.thenCompose(r);
2708 <        f.complete(v1);
2817 <        checkCompletedWithWrappedCFException(g);
2818 <        checkCompletedNormally(f, v1);
2819 <        }
2820 <    }
2821 <
2822 <    public void testThenCompose_actionFailed2() {
2823 <        for (ExecutionMode m : ExecutionMode.values())
2824 <        for (Integer v1 : new Integer[] { 1, null }) {
2708 >        if (createIncomplete) f.complete(v1);
2709  
2826 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2827 –        f.complete(v1);
2828 –        final FailingCompletableFutureFunction r
2829 –            = new FailingCompletableFutureFunction();
2830 –        final CompletableFuture<Integer> g = f.thenCompose(r);
2710          checkCompletedWithWrappedCFException(g);
2711          checkCompletedNormally(f, v1);
2712 <        }
2834 <    }
2712 >    }}
2713  
2714      /**
2715       * thenCompose result completes exceptionally if source cancelled
2716       */
2717 <    public void testThenCompose_sourceCancelled1() {
2717 >    public void testThenCompose_sourceCancelled() {
2718          for (ExecutionMode m : ExecutionMode.values())
2719 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
2720 <
2719 >        for (boolean createIncomplete : new boolean[] { true, false })
2720 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2721 >    {
2722          final CompletableFuture<Integer> f = new CompletableFuture<>();
2723          final CompletableFutureInc r = new CompletableFutureInc();
2724 +        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2725          final CompletableFuture<Integer> g = f.thenCompose(r);
2726 <        assertTrue(f.cancel(mayInterruptIfRunning));
2727 <        checkCompletedWithWrappedCancellationException(g);
2728 <        checkCancelled(f);
2726 >        if (createIncomplete) {
2727 >            checkIncomplete(g);
2728 >            assertTrue(f.cancel(mayInterruptIfRunning));
2729          }
2850 –    }
2730  
2852 –    public void testThenCompose_sourceCancelled2() {
2853 –        for (ExecutionMode m : ExecutionMode.values())
2854 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
2855 –
2856 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2857 –        assertTrue(f.cancel(mayInterruptIfRunning));
2858 –        final CompletableFutureInc r = new CompletableFutureInc();
2859 –        final CompletableFuture<Integer> g = f.thenCompose(r);
2731          checkCompletedWithWrappedCancellationException(g);
2732          checkCancelled(f);
2733 <        }
2863 <    }
2864 <
2865 <    // asyncs
2866 <
2867 <    /**
2868 <     * thenRunAsync result completes normally after normal completion of source
2869 <     */
2870 <    public void testThenRunAsync() {
2871 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2872 <        Noop r = new Noop();
2873 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2874 <        f.complete(null);
2875 <        checkCompletedNormally(g, null);
2876 <
2877 <        // reordered version
2878 <        f = new CompletableFuture<>();
2879 <        f.complete(null);
2880 <        r = new Noop();
2881 <        g = f.thenRunAsync(r);
2882 <        checkCompletedNormally(g, null);
2883 <    }
2884 <
2885 <    /**
2886 <     * thenRunAsync result completes exceptionally after exceptional
2887 <     * completion of source
2888 <     */
2889 <    public void testThenRunAsync2() {
2890 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2891 <        Noop r = new Noop();
2892 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2893 <        f.completeExceptionally(new CFException());
2894 <        try {
2895 <            g.join();
2896 <            shouldThrow();
2897 <        } catch (CompletionException success) {}
2898 <        checkCompletedWithWrappedCFException(g);
2899 <    }
2900 <
2901 <    /**
2902 <     * thenRunAsync result completes exceptionally if action does
2903 <     */
2904 <    public void testThenRunAsync3() {
2905 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2906 <        FailingNoop r = new FailingNoop();
2907 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2908 <        f.complete(null);
2909 <        checkCompletedWithWrappedCFException(g);
2910 <    }
2911 <
2912 <    /**
2913 <     * thenRunAsync result completes exceptionally if source cancelled
2914 <     */
2915 <    public void testThenRunAsync4() {
2916 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2917 <        Noop r = new Noop();
2918 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2919 <        assertTrue(f.cancel(true));
2920 <        checkCompletedWithWrappedCancellationException(g);
2921 <    }
2922 <
2923 <    /**
2924 <     * thenApplyAsync result completes normally after normal completion of source
2925 <     */
2926 <    public void testThenApplyAsync() {
2927 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2928 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2929 <        f.complete(one);
2930 <        checkCompletedNormally(g, two);
2931 <    }
2932 <
2933 <    /**
2934 <     * thenApplyAsync result completes exceptionally after exceptional
2935 <     * completion of source
2936 <     */
2937 <    public void testThenApplyAsync2() {
2938 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2939 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2940 <        f.completeExceptionally(new CFException());
2941 <        checkCompletedWithWrappedCFException(g);
2942 <    }
2943 <
2944 <    /**
2945 <     * thenApplyAsync result completes exceptionally if action does
2946 <     */
2947 <    public void testThenApplyAsync3() {
2948 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2949 <        FailingFunction r = new FailingFunction();
2950 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2951 <        f.complete(null);
2952 <        checkCompletedWithWrappedCFException(g);
2953 <    }
2954 <
2955 <    /**
2956 <     * thenApplyAsync result completes exceptionally if source cancelled
2957 <     */
2958 <    public void testThenApplyAsync4() {
2959 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2960 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2961 <        assertTrue(f.cancel(true));
2962 <        checkCompletedWithWrappedCancellationException(g);
2963 <    }
2964 <
2965 <    /**
2966 <     * thenAcceptAsync result completes normally after normal
2967 <     * completion of source
2968 <     */
2969 <    public void testThenAcceptAsync() {
2970 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2971 <        IncAction r = new IncAction();
2972 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2973 <        f.complete(one);
2974 <        checkCompletedNormally(g, null);
2975 <        assertEquals(r.value, (Integer) 2);
2976 <    }
2977 <
2978 <    /**
2979 <     * thenAcceptAsync result completes exceptionally after exceptional
2980 <     * completion of source
2981 <     */
2982 <    public void testThenAcceptAsync2() {
2983 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2984 <        IncAction r = new IncAction();
2985 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2986 <        f.completeExceptionally(new CFException());
2987 <        checkCompletedWithWrappedCFException(g);
2988 <    }
2989 <
2990 <    /**
2991 <     * thenAcceptAsync result completes exceptionally if action does
2992 <     */
2993 <    public void testThenAcceptAsync3() {
2994 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2995 <        FailingConsumer r = new FailingConsumer();
2996 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2997 <        f.complete(null);
2998 <        checkCompletedWithWrappedCFException(g);
2999 <    }
3000 <
3001 <    /**
3002 <     * thenAcceptAsync result completes exceptionally if source cancelled
3003 <     */
3004 <    public void testThenAcceptAsync4() {
3005 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3006 <        IncAction r = new IncAction();
3007 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3008 <        assertTrue(f.cancel(true));
3009 <        checkCompletedWithWrappedCancellationException(g);
3010 <    }
3011 <
3012 <    // async with explicit executors
3013 <
3014 <    /**
3015 <     * thenRunAsync result completes normally after normal completion of source
3016 <     */
3017 <    public void testThenRunAsyncE() {
3018 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3019 <        Noop r = new Noop();
3020 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3021 <        f.complete(null);
3022 <        checkCompletedNormally(g, null);
3023 <
3024 <        // reordered version
3025 <        f = new CompletableFuture<>();
3026 <        f.complete(null);
3027 <        r = new Noop();
3028 <        g = f.thenRunAsync(r, new ThreadExecutor());
3029 <        checkCompletedNormally(g, null);
3030 <    }
3031 <
3032 <    /**
3033 <     * thenRunAsync result completes exceptionally after exceptional
3034 <     * completion of source
3035 <     */
3036 <    public void testThenRunAsync2E() {
3037 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3038 <        Noop r = new Noop();
3039 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3040 <        f.completeExceptionally(new CFException());
3041 <        try {
3042 <            g.join();
3043 <            shouldThrow();
3044 <        } catch (CompletionException success) {}
3045 <        checkCompletedWithWrappedCFException(g);
3046 <    }
3047 <
3048 <    /**
3049 <     * thenRunAsync result completes exceptionally if action does
3050 <     */
3051 <    public void testThenRunAsync3E() {
3052 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3053 <        FailingNoop r = new FailingNoop();
3054 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3055 <        f.complete(null);
3056 <        checkCompletedWithWrappedCFException(g);
3057 <    }
3058 <
3059 <    /**
3060 <     * thenRunAsync result completes exceptionally if source cancelled
3061 <     */
3062 <    public void testThenRunAsync4E() {
3063 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3064 <        Noop r = new Noop();
3065 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3066 <        assertTrue(f.cancel(true));
3067 <        checkCompletedWithWrappedCancellationException(g);
3068 <    }
3069 <
3070 <    /**
3071 <     * thenApplyAsync result completes normally after normal completion of source
3072 <     */
3073 <    public void testThenApplyAsyncE() {
3074 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3075 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3076 <        f.complete(one);
3077 <        checkCompletedNormally(g, two);
3078 <    }
3079 <
3080 <    /**
3081 <     * thenApplyAsync result completes exceptionally after exceptional
3082 <     * completion of source
3083 <     */
3084 <    public void testThenApplyAsync2E() {
3085 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3086 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3087 <        f.completeExceptionally(new CFException());
3088 <        checkCompletedWithWrappedCFException(g);
3089 <    }
3090 <
3091 <    /**
3092 <     * thenApplyAsync result completes exceptionally if action does
3093 <     */
3094 <    public void testThenApplyAsync3E() {
3095 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3096 <        FailingFunction r = new FailingFunction();
3097 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3098 <        f.complete(null);
3099 <        checkCompletedWithWrappedCFException(g);
3100 <    }
3101 <
3102 <    /**
3103 <     * thenApplyAsync result completes exceptionally if source cancelled
3104 <     */
3105 <    public void testThenApplyAsync4E() {
3106 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3107 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3108 <        assertTrue(f.cancel(true));
3109 <        checkCompletedWithWrappedCancellationException(g);
3110 <    }
3111 <
3112 <    /**
3113 <     * thenAcceptAsync result completes normally after normal
3114 <     * completion of source
3115 <     */
3116 <    public void testThenAcceptAsyncE() {
3117 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3118 <        IncAction r = new IncAction();
3119 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3120 <        f.complete(one);
3121 <        checkCompletedNormally(g, null);
3122 <        assertEquals(r.value, (Integer) 2);
3123 <    }
3124 <
3125 <    /**
3126 <     * thenAcceptAsync result completes exceptionally after exceptional
3127 <     * completion of source
3128 <     */
3129 <    public void testThenAcceptAsync2E() {
3130 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3131 <        IncAction r = new IncAction();
3132 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3133 <        f.completeExceptionally(new CFException());
3134 <        checkCompletedWithWrappedCFException(g);
3135 <    }
3136 <
3137 <    /**
3138 <     * thenAcceptAsync result completes exceptionally if action does
3139 <     */
3140 <    public void testThenAcceptAsync3E() {
3141 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3142 <        FailingConsumer r = new FailingConsumer();
3143 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3144 <        f.complete(null);
3145 <        checkCompletedWithWrappedCFException(g);
3146 <    }
3147 <
3148 <    /**
3149 <     * thenAcceptAsync result completes exceptionally if source cancelled
3150 <     */
3151 <    public void testThenAcceptAsync4E() {
3152 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3153 <        IncAction r = new IncAction();
3154 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3155 <        assertTrue(f.cancel(true));
3156 <        checkCompletedWithWrappedCancellationException(g);
3157 <    }
2733 >    }}
2734  
2735      // other static methods
2736  
# Line 3355 | Line 2931 | public class CompletableFutureTest exten
2931       * source result.
2932       */
2933      public void testWhenComplete_normalCompletion1() {
3358 –        for (boolean createIncomplete : new boolean[] { true, false })
2934          for (ExecutionMode m : ExecutionMode.values())
2935 <        for (Integer v1 : new Integer[] { 1, null }) {
2936 <
2937 <        final AtomicInteger a = new AtomicInteger();
2935 >        for (boolean createIncomplete : new boolean[] { true, false })
2936 >        for (Integer v1 : new Integer[] { 1, null })
2937 >    {
2938 >        final AtomicInteger a = new AtomicInteger(0);
2939          final CompletableFuture<Integer> f = new CompletableFuture<>();
2940          if (!createIncomplete) f.complete(v1);
2941 <        final CompletableFuture<Integer> g =
2942 <            m.whenComplete(f,
2943 <                           (Integer x, Throwable t) -> {
2944 <                               threadAssertSame(x, v1);
2945 <                               threadAssertNull(t);
2946 <                               a.getAndIncrement();
2947 <                           });
2941 >        final CompletableFuture<Integer> g = m.whenComplete
2942 >            (f,
2943 >             (Integer x, Throwable t) -> {
2944 >                threadAssertSame(x, v1);
2945 >                threadAssertNull(t);
2946 >                a.getAndIncrement();
2947 >            });
2948          if (createIncomplete) f.complete(v1);
2949 <        checkCompletedNormally(f, v1);
2949 >
2950          checkCompletedNormally(g, v1);
2951 <        assertEquals(a.get(), 1);
2952 <        }
2953 <    }
2951 >        checkCompletedNormally(f, v1);
2952 >        assertEquals(1, a.get());
2953 >    }}
2954  
2955      /**
2956       * whenComplete action executes on exceptional completion, propagating
2957       * source result.
2958       */
2959      public void testWhenComplete_exceptionalCompletion() {
3384 –        for (boolean createIncomplete : new boolean[] { true, false })
2960          for (ExecutionMode m : ExecutionMode.values())
2961 <        for (Integer v1 : new Integer[] { 1, null }) {
2962 <
2963 <        final AtomicInteger a = new AtomicInteger();
2961 >        for (boolean createIncomplete : new boolean[] { true, false })
2962 >        for (Integer v1 : new Integer[] { 1, null })
2963 >    {
2964 >        final AtomicInteger a = new AtomicInteger(0);
2965          final CFException ex = new CFException();
2966          final CompletableFuture<Integer> f = new CompletableFuture<>();
2967          if (!createIncomplete) f.completeExceptionally(ex);
# Line 3399 | Line 2975 | public class CompletableFutureTest exten
2975          if (createIncomplete) f.completeExceptionally(ex);
2976          checkCompletedWithWrappedCFException(f, ex);
2977          checkCompletedWithWrappedCFException(g, ex);
2978 <        assertEquals(a.get(), 1);
2979 <        }
2980 <    }
2978 >        assertEquals(1, a.get());
2979 >    }}
2980 >
2981 >    /**
2982 >     * whenComplete action executes on cancelled source, propagating
2983 >     * CancellationException.
2984 >     */
2985 >    public void testWhenComplete_sourceCancelled() {
2986 >        for (ExecutionMode m : ExecutionMode.values())
2987 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2988 >        for (boolean createIncomplete : new boolean[] { true, false })
2989 >    {
2990 >        final AtomicInteger a = new AtomicInteger(0);
2991 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2992 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2993 >        final CompletableFuture<Integer> g = m.whenComplete
2994 >            (f,
2995 >             (Integer x, Throwable t) -> {
2996 >                threadAssertNull(x);
2997 >                threadAssertTrue(t instanceof CancellationException);
2998 >                a.getAndIncrement();
2999 >            });
3000 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3001 >
3002 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
3003 >        checkCompletedWithWrappedCancellationException(g);
3004 >        checkCancelled(f);
3005 >        assertEquals(1, a.get());
3006 >    }}
3007  
3008      /**
3009       * If a whenComplete action throws an exception when triggered by
# Line 3410 | Line 3012 | public class CompletableFutureTest exten
3012      public void testWhenComplete_actionFailed() {
3013          for (boolean createIncomplete : new boolean[] { true, false })
3014          for (ExecutionMode m : ExecutionMode.values())
3015 <        for (Integer v1 : new Integer[] { 1, null }) {
3016 <
3015 >        for (Integer v1 : new Integer[] { 1, null })
3016 >    {
3017 >        final AtomicInteger a = new AtomicInteger(0);
3018          final CFException ex = new CFException();
3019          final CompletableFuture<Integer> f = new CompletableFuture<>();
3020          if (!createIncomplete) f.complete(v1);
# Line 3420 | Line 3023 | public class CompletableFutureTest exten
3023               (Integer x, Throwable t) -> {
3024                  threadAssertSame(x, v1);
3025                  threadAssertNull(t);
3026 +                a.getAndIncrement();
3027                  throw ex;
3028              });
3029          if (createIncomplete) f.complete(v1);
3030          checkCompletedNormally(f, v1);
3031          checkCompletedWithWrappedCFException(g, ex);
3032 <        }
3033 <    }
3032 >        assertEquals(1, a.get());
3033 >    }}
3034  
3035      /**
3036       * If a whenComplete action throws an exception when triggered by
# Line 3436 | Line 3040 | public class CompletableFutureTest exten
3040      public void testWhenComplete_actionFailedSourceFailed() {
3041          for (boolean createIncomplete : new boolean[] { true, false })
3042          for (ExecutionMode m : ExecutionMode.values())
3043 <        for (Integer v1 : new Integer[] { 1, null }) {
3044 <
3043 >        for (Integer v1 : new Integer[] { 1, null })
3044 >    {
3045 >        final AtomicInteger a = new AtomicInteger(0);
3046          final CFException ex1 = new CFException();
3047          final CFException ex2 = new CFException();
3048          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3448 | Line 3053 | public class CompletableFutureTest exten
3053               (Integer x, Throwable t) -> {
3054                  threadAssertSame(t, ex1);
3055                  threadAssertNull(x);
3056 +                a.getAndIncrement();
3057                  throw ex2;
3058              });
3059          if (createIncomplete) f.completeExceptionally(ex1);
3060  
3061          checkCompletedWithWrappedCFException(f, ex1);
3062          checkCompletedWithWrappedCFException(g, ex1);
3063 <        }
3064 <    }
3459 <
3460 <    /**
3461 <     * handleAsync action completes normally with function value on
3462 <     * either normal or exceptional completion of source
3463 <     */
3464 <    public void testHandleAsync() {
3465 <        CompletableFuture<Integer> f, g;
3466 <        IntegerHandler r;
3467 <
3468 <        f = new CompletableFuture<>();
3469 <        g = f.handleAsync(r = new IntegerHandler());
3470 <        assertEquals(0, r.invocationCount);
3471 <        f.completeExceptionally(new CFException());
3472 <        checkCompletedWithWrappedCFException(f);
3473 <        checkCompletedNormally(g, three);
3474 <        assertEquals(1, r.invocationCount);
3475 <
3476 <        f = new CompletableFuture<>();
3477 <        g = f.handleAsync(r = new IntegerHandler());
3478 <        assertEquals(0, r.invocationCount);
3479 <        f.completeExceptionally(new CFException());
3480 <        checkCompletedWithWrappedCFException(f);
3481 <        checkCompletedNormally(g, three);
3482 <        assertEquals(1, r.invocationCount);
3483 <
3484 <        f = new CompletableFuture<>();
3485 <        g = f.handleAsync(r = new IntegerHandler());
3486 <        assertEquals(0, r.invocationCount);
3487 <        f.complete(one);
3488 <        checkCompletedNormally(f, one);
3489 <        checkCompletedNormally(g, two);
3490 <        assertEquals(1, r.invocationCount);
3491 <
3492 <        f = new CompletableFuture<>();
3493 <        g = f.handleAsync(r = new IntegerHandler());
3494 <        assertEquals(0, r.invocationCount);
3495 <        f.complete(one);
3496 <        checkCompletedNormally(f, one);
3497 <        checkCompletedNormally(g, two);
3498 <        assertEquals(1, r.invocationCount);
3499 <    }
3500 <
3501 <    /**
3502 <     * handleAsync action with Executor completes normally with
3503 <     * function value on either normal or exceptional completion of
3504 <     * source
3505 <     */
3506 <    public void testHandleAsync2() {
3507 <        CompletableFuture<Integer> f, g;
3508 <        ThreadExecutor exec = new ThreadExecutor();
3509 <        IntegerHandler r;
3510 <
3511 <        f = new CompletableFuture<>();
3512 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3513 <        assertEquals(0, r.invocationCount);
3514 <        f.completeExceptionally(new CFException());
3515 <        checkCompletedWithWrappedCFException(f);
3516 <        checkCompletedNormally(g, three);
3517 <        assertEquals(1, r.invocationCount);
3518 <
3519 <        f = new CompletableFuture<>();
3520 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3521 <        assertEquals(0, r.invocationCount);
3522 <        f.completeExceptionally(new CFException());
3523 <        checkCompletedWithWrappedCFException(f);
3524 <        checkCompletedNormally(g, three);
3525 <        assertEquals(1, r.invocationCount);
3526 <
3527 <        f = new CompletableFuture<>();
3528 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3529 <        assertEquals(0, r.invocationCount);
3530 <        f.complete(one);
3531 <        checkCompletedNormally(f, one);
3532 <        checkCompletedNormally(g, two);
3533 <        assertEquals(1, r.invocationCount);
3534 <
3535 <        f = new CompletableFuture<>();
3536 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3537 <        assertEquals(0, r.invocationCount);
3538 <        f.complete(one);
3539 <        checkCompletedNormally(f, one);
3540 <        checkCompletedNormally(g, two);
3541 <        assertEquals(1, r.invocationCount);
3542 <    }
3063 >        assertEquals(1, a.get());
3064 >    }}
3065  
3066   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines