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.49 by jsr166, Mon Jun 2 19:20:51 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 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 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) f.complete(v1);
987  
804 –        f = new CompletableFuture<>();
805 –        f.complete(null);
806 –        g = f.thenRun(r = new Noop());
988          checkCompletedNormally(g, null);
989 +        checkCompletedNormally(f, v1);
990          assertEquals(1, r.invocationCount);
991 <    }
991 >    }}
992  
993      /**
994       * thenRun result completes exceptionally after exceptional
995       * completion of source
996       */
997 <    public void testThenRun2() {
998 <        CompletableFuture<Integer> f;
999 <        CompletableFuture<Void> g;
1000 <        Noop r;
1001 <
1002 <        f = new CompletableFuture<>();
1003 <        g = f.thenRun(r = new Noop());
1004 <        f.completeExceptionally(new CFException());
1005 <        checkCompletedWithWrappedCFException(g);
1006 <        assertEquals(0, r.invocationCount);
997 >    public void testThenRun_exceptionalCompletion() {
998 >        for (ExecutionMode m : ExecutionMode.values())
999 >        for (boolean createIncomplete : new boolean[] { true, false })
1000 >    {
1001 >        final CFException ex = new CFException();
1002 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1003 >        final Noop r = new Noop();
1004 >        if (!createIncomplete) f.completeExceptionally(ex);
1005 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1006 >        if (createIncomplete) f.completeExceptionally(ex);
1007  
1008 <        f = new CompletableFuture<>();
1009 <        f.completeExceptionally(new CFException());
828 <        g = f.thenRun(r = new Noop());
829 <        checkCompletedWithWrappedCFException(g);
1008 >        checkCompletedWithWrappedCFException(g, ex);
1009 >        checkCompletedWithWrappedCFException(f, ex);
1010          assertEquals(0, r.invocationCount);
1011 <    }
1011 >    }}
1012  
1013      /**
1014 <     * thenRun result completes exceptionally if action does
1014 >     * thenRun result completes exceptionally if source cancelled
1015       */
1016 <    public void testThenRun3() {
1017 <        CompletableFuture<Integer> f;
1018 <        CompletableFuture<Void> g;
1019 <        FailingNoop r;
1020 <
1021 <        f = new CompletableFuture<>();
1022 <        g = f.thenRun(r = new FailingNoop());
1023 <        f.complete(null);
1024 <        checkCompletedWithWrappedCFException(g);
1016 >    public void testThenRun_sourceCancelled() {
1017 >        for (ExecutionMode m : ExecutionMode.values())
1018 >        for (boolean createIncomplete : new boolean[] { true, false })
1019 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1020 >    {
1021 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1022 >        final Noop r = new Noop();
1023 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1024 >        final CompletableFuture<Void> g = f.thenRun(r);
1025 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1026  
1027 <        f = new CompletableFuture<>();
1028 <        f.complete(null);
1029 <        g = f.thenRun(r = new FailingNoop());
1030 <        checkCompletedWithWrappedCFException(g);
850 <    }
1027 >        checkCompletedWithWrappedCancellationException(g);
1028 >        checkCancelled(f);
1029 >        assertEquals(0, r.invocationCount);
1030 >    }}
1031  
1032      /**
1033 <     * thenRun result completes exceptionally if source cancelled
1033 >     * thenRun result completes exceptionally if action does
1034       */
1035 <    public void testThenRun4() {
1036 <        CompletableFuture<Integer> f;
1037 <        CompletableFuture<Void> g;
1038 <        Noop r;
1039 <
1040 <        f = new CompletableFuture<>();
1041 <        g = f.thenRun(r = new Noop());
1042 <        assertTrue(f.cancel(true));
1043 <        checkCompletedWithWrappedCancellationException(g);
1035 >    public void testThenRun_actionFailed() {
1036 >        for (ExecutionMode m : ExecutionMode.values())
1037 >        for (boolean createIncomplete : new boolean[] { true, false })
1038 >        for (Integer v1 : new Integer[] { 1, null })
1039 >    {
1040 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1041 >        final FailingNoop r = new FailingNoop();
1042 >        if (!createIncomplete) f.complete(v1);
1043 >        final CompletableFuture<Void> g = f.thenRun(r);
1044 >        if (createIncomplete) f.complete(v1);
1045  
1046 <        f = new CompletableFuture<>();
1047 <        assertTrue(f.cancel(true));
1048 <        g = f.thenRun(r = new Noop());
868 <        checkCompletedWithWrappedCancellationException(g);
869 <    }
1046 >        checkCompletedWithWrappedCFException(g);
1047 >        checkCompletedNormally(f, v1);
1048 >    }}
1049  
1050      /**
1051       * thenApply result completes normally after normal completion of source
1052       */
1053 <    public void testThenApply() {
1054 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1055 <        CompletableFuture<Integer> g = f.thenApply(inc);
1056 <        f.complete(one);
1057 <        checkCompletedNormally(g, two);
1058 <    }
1053 >    public void testThenApply_normalCompletion() {
1054 >        for (ExecutionMode m : ExecutionMode.values())
1055 >        for (boolean createIncomplete : new boolean[] { true, false })
1056 >        for (Integer v1 : new Integer[] { 1, null })
1057 >    {
1058 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1059 >        final IncFunction r = new IncFunction();
1060 >        if (!createIncomplete) f.complete(v1);
1061 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1062 >        if (createIncomplete) {
1063 >            checkIncomplete(g);
1064 >            f.complete(v1);
1065 >        }
1066 >
1067 >        checkCompletedNormally(g, inc(v1));
1068 >        checkCompletedNormally(f, v1);
1069 >        assertEquals(1, r.invocationCount);
1070 >    }}
1071  
1072      /**
1073       * thenApply result completes exceptionally after exceptional
1074       * completion of source
1075       */
1076 <    public void testThenApply2() {
1077 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1078 <        CompletableFuture<Integer> g = f.thenApply(inc);
1079 <        f.completeExceptionally(new CFException());
1080 <        checkCompletedWithWrappedCFException(g);
1081 <    }
1076 >    public void testThenApply_exceptionalCompletion() {
1077 >        for (ExecutionMode m : ExecutionMode.values())
1078 >        for (boolean createIncomplete : new boolean[] { true, false })
1079 >    {
1080 >        final CFException ex = new CFException();
1081 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1082 >        final IncFunction r = new IncFunction();
1083 >        if (!createIncomplete) f.completeExceptionally(ex);
1084 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1085 >        if (createIncomplete) f.completeExceptionally(ex);
1086  
1087 <    /**
1088 <     * thenApply result completes exceptionally if action does
1089 <     */
1090 <    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 <    }
1087 >        checkCompletedWithWrappedCFException(g, ex);
1088 >        checkCompletedWithWrappedCFException(f, ex);
1089 >        assertEquals(0, r.invocationCount);
1090 >    }}
1091  
1092      /**
1093       * thenApply result completes exceptionally if source cancelled
1094       */
1095 <    public void testThenApply4() {
1096 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1097 <        CompletableFuture<Integer> g = f.thenApply(inc);
1098 <        assertTrue(f.cancel(true));
1095 >    public void testThenApply_sourceCancelled() {
1096 >        for (ExecutionMode m : ExecutionMode.values())
1097 >        for (boolean createIncomplete : new boolean[] { true, false })
1098 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1099 >    {
1100 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1101 >        final IncFunction r = new IncFunction();
1102 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1103 >        final CompletableFuture<Integer> g = f.thenApply(r);
1104 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1105 >
1106          checkCompletedWithWrappedCancellationException(g);
1107 <    }
1107 >        checkCancelled(f);
1108 >        assertEquals(0, r.invocationCount);
1109 >    }}
1110 >
1111 >    /**
1112 >     * thenApply result completes exceptionally if action does
1113 >     */
1114 >    public void testThenApply_actionFailed() {
1115 >        for (ExecutionMode m : ExecutionMode.values())
1116 >        for (boolean createIncomplete : new boolean[] { true, false })
1117 >        for (Integer v1 : new Integer[] { 1, null })
1118 >    {
1119 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1120 >        final FailingFunction r = new FailingFunction();
1121 >        if (!createIncomplete) f.complete(v1);
1122 >        final CompletableFuture<Integer> g = f.thenApply(r);
1123 >        if (createIncomplete) f.complete(v1);
1124 >
1125 >        checkCompletedWithWrappedCFException(g);
1126 >        checkCompletedNormally(f, v1);
1127 >    }}
1128  
1129      /**
1130       * thenAccept result completes normally after normal completion of source
# Line 965 | Line 1182 | public class CompletableFutureTest exten
1182          for (boolean fFirst : new boolean[] { true, false })
1183          for (ExecutionMode m : ExecutionMode.values())
1184          for (Integer v1 : new Integer[] { 1, null })
1185 <        for (Integer v2 : new Integer[] { 2, null }) {
1186 <
1185 >        for (Integer v2 : new Integer[] { 2, null })
1186 >    {
1187          final CompletableFuture<Integer> f = new CompletableFuture<>();
1188          final CompletableFuture<Integer> g = new CompletableFuture<>();
1189          final SubtractFunction r = new SubtractFunction();
# Line 989 | Line 1206 | public class CompletableFutureTest exten
1206          checkCompletedNormally(f, v1);
1207          checkCompletedNormally(g, v2);
1208          assertEquals(1, r.invocationCount);
1209 <        }
993 <    }
1209 >    }}
1210  
1211      /**
1212       * thenCombine result completes exceptionally after exceptional
# Line 998 | Line 1214 | public class CompletableFutureTest exten
1214       */
1215      public void testThenCombine_exceptionalCompletion1() {
1216          for (ExecutionMode m : ExecutionMode.values())
1217 <        for (Integer v1 : new Integer[] { 1, null }) {
1218 <
1217 >        for (Integer v1 : new Integer[] { 1, null })
1218 >    {
1219          final CompletableFuture<Integer> f = new CompletableFuture<>();
1220          final CompletableFuture<Integer> g = new CompletableFuture<>();
1221          final SubtractFunction r = new SubtractFunction();
# Line 1014 | Line 1230 | public class CompletableFutureTest exten
1230          checkCompletedWithWrappedCFException(f, ex);
1231          assertEquals(0, r.invocationCount);
1232          checkCompletedNormally(g, v1);
1233 <        }
1018 <    }
1233 >    }}
1234  
1235      public void testThenCombine_exceptionalCompletion2() {
1236          for (ExecutionMode m : ExecutionMode.values())
1237 <        for (Integer v1 : new Integer[] { 1, null }) {
1238 <
1237 >        for (Integer v1 : new Integer[] { 1, null })
1238 >    {
1239          final CompletableFuture<Integer> f = new CompletableFuture<>();
1240          final CompletableFuture<Integer> g = new CompletableFuture<>();
1241          final SubtractFunction r = new SubtractFunction();
# Line 1035 | Line 1250 | public class CompletableFutureTest exten
1250          checkCompletedWithWrappedCFException(g, ex);
1251          assertEquals(0, r.invocationCount);
1252          checkCompletedNormally(f, v1);
1253 <        }
1039 <    }
1253 >    }}
1254  
1255      public void testThenCombine_exceptionalCompletion3() {
1256          for (ExecutionMode m : ExecutionMode.values())
1257 <        for (Integer v1 : new Integer[] { 1, null }) {
1258 <
1257 >        for (Integer v1 : new Integer[] { 1, null })
1258 >    {
1259          final CompletableFuture<Integer> f = new CompletableFuture<>();
1260          final CompletableFuture<Integer> g = new CompletableFuture<>();
1261          final SubtractFunction r = new SubtractFunction();
# Line 1055 | Line 1269 | public class CompletableFutureTest exten
1269          checkCompletedWithWrappedCFException(g, ex);
1270          assertEquals(0, r.invocationCount);
1271          checkCompletedNormally(f, v1);
1272 <        }
1059 <    }
1272 >    }}
1273  
1274      public void testThenCombine_exceptionalCompletion4() {
1275          for (ExecutionMode m : ExecutionMode.values())
1276 <        for (Integer v1 : new Integer[] { 1, null }) {
1277 <
1276 >        for (Integer v1 : new Integer[] { 1, null })
1277 >    {
1278          final CompletableFuture<Integer> f = new CompletableFuture<>();
1279          final CompletableFuture<Integer> g = new CompletableFuture<>();
1280          final SubtractFunction r = new SubtractFunction();
# Line 1075 | Line 1288 | public class CompletableFutureTest exten
1288          checkCompletedWithWrappedCFException(f, ex);
1289          assertEquals(0, r.invocationCount);
1290          checkCompletedNormally(g, v1);
1291 <        }
1079 <    }
1291 >    }}
1292  
1293      /**
1294       * thenCombine result completes exceptionally if action does
# Line 1084 | Line 1296 | public class CompletableFutureTest exten
1296      public void testThenCombine_actionFailed1() {
1297          for (ExecutionMode m : ExecutionMode.values())
1298          for (Integer v1 : new Integer[] { 1, null })
1299 <        for (Integer v2 : new Integer[] { 2, null }) {
1300 <
1299 >        for (Integer v2 : new Integer[] { 2, null })
1300 >    {
1301          final CompletableFuture<Integer> f = new CompletableFuture<>();
1302          final CompletableFuture<Integer> g = new CompletableFuture<>();
1303          final FailingBiFunction r = new FailingBiFunction();
# Line 1098 | Line 1310 | public class CompletableFutureTest exten
1310          checkCompletedWithWrappedCFException(h);
1311          checkCompletedNormally(f, v1);
1312          checkCompletedNormally(g, v2);
1313 <        }
1102 <    }
1313 >    }}
1314  
1315      public void testThenCombine_actionFailed2() {
1316          for (ExecutionMode m : ExecutionMode.values())
1317          for (Integer v1 : new Integer[] { 1, null })
1318 <        for (Integer v2 : new Integer[] { 2, null }) {
1319 <
1318 >        for (Integer v2 : new Integer[] { 2, null })
1319 >    {
1320          final CompletableFuture<Integer> f = new CompletableFuture<>();
1321          final CompletableFuture<Integer> g = new CompletableFuture<>();
1322          final FailingBiFunction r = new FailingBiFunction();
# Line 1118 | Line 1329 | public class CompletableFutureTest exten
1329          checkCompletedWithWrappedCFException(h);
1330          checkCompletedNormally(f, v1);
1331          checkCompletedNormally(g, v2);
1332 <        }
1122 <    }
1332 >    }}
1333  
1334      /**
1335       * thenCombine result completes exceptionally if either source cancelled
# Line 1127 | Line 1337 | public class CompletableFutureTest exten
1337      public void testThenCombine_sourceCancelled1() {
1338          for (ExecutionMode m : ExecutionMode.values())
1339          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1340 <        for (Integer v1 : new Integer[] { 1, null }) {
1341 <
1340 >        for (Integer v1 : new Integer[] { 1, null })
1341 >    {
1342          final CompletableFuture<Integer> f = new CompletableFuture<>();
1343          final CompletableFuture<Integer> g = new CompletableFuture<>();
1344          final SubtractFunction r = new SubtractFunction();
# Line 1142 | Line 1352 | public class CompletableFutureTest exten
1352          checkCancelled(f);
1353          assertEquals(0, r.invocationCount);
1354          checkCompletedNormally(g, v1);
1355 <        }
1146 <    }
1355 >    }}
1356  
1357      public void testThenCombine_sourceCancelled2() {
1358          for (ExecutionMode m : ExecutionMode.values())
1359          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1360 <        for (Integer v1 : new Integer[] { 1, null }) {
1361 <
1360 >        for (Integer v1 : new Integer[] { 1, null })
1361 >    {
1362          final CompletableFuture<Integer> f = new CompletableFuture<>();
1363          final CompletableFuture<Integer> g = new CompletableFuture<>();
1364          final SubtractFunction r = new SubtractFunction();
# Line 1163 | Line 1372 | public class CompletableFutureTest exten
1372          checkCancelled(g);
1373          assertEquals(0, r.invocationCount);
1374          checkCompletedNormally(f, v1);
1375 <        }
1167 <    }
1375 >    }}
1376  
1377      public void testThenCombine_sourceCancelled3() {
1378          for (ExecutionMode m : ExecutionMode.values())
1379          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1380 <        for (Integer v1 : new Integer[] { 1, null }) {
1381 <
1380 >        for (Integer v1 : new Integer[] { 1, null })
1381 >    {
1382          final CompletableFuture<Integer> f = new CompletableFuture<>();
1383          final CompletableFuture<Integer> g = new CompletableFuture<>();
1384          final SubtractFunction r = new SubtractFunction();
# Line 1183 | Line 1391 | public class CompletableFutureTest exten
1391          checkCancelled(g);
1392          assertEquals(0, r.invocationCount);
1393          checkCompletedNormally(f, v1);
1394 <        }
1187 <    }
1394 >    }}
1395  
1396      public void testThenCombine_sourceCancelled4() {
1397          for (ExecutionMode m : ExecutionMode.values())
1398          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1399 <        for (Integer v1 : new Integer[] { 1, null }) {
1400 <
1399 >        for (Integer v1 : new Integer[] { 1, null })
1400 >    {
1401          final CompletableFuture<Integer> f = new CompletableFuture<>();
1402          final CompletableFuture<Integer> g = new CompletableFuture<>();
1403          final SubtractFunction r = new SubtractFunction();
# Line 1203 | Line 1410 | public class CompletableFutureTest exten
1410          checkCancelled(f);
1411          assertEquals(0, r.invocationCount);
1412          checkCompletedNormally(g, v1);
1413 <        }
1207 <    }
1413 >    }}
1414  
1415      /**
1416       * thenAcceptBoth result completes normally after normal
# Line 1213 | Line 1419 | public class CompletableFutureTest exten
1419      public void testThenAcceptBoth_normalCompletion1() {
1420          for (ExecutionMode m : ExecutionMode.values())
1421          for (Integer v1 : new Integer[] { 1, null })
1422 <        for (Integer v2 : new Integer[] { 2, null }) {
1423 <
1422 >        for (Integer v2 : new Integer[] { 2, null })
1423 >    {
1424          final CompletableFuture<Integer> f = new CompletableFuture<>();
1425          final CompletableFuture<Integer> g = new CompletableFuture<>();
1426          final SubtractAction r = new SubtractAction();
# Line 1226 | Line 1432 | public class CompletableFutureTest exten
1432          g.complete(v2);
1433  
1434          checkCompletedNormally(h, null);
1435 <        assertEquals(r.value, subtract(v1, v2));
1435 >        assertEquals(subtract(v1, v2), r.value);
1436          checkCompletedNormally(f, v1);
1437          checkCompletedNormally(g, v2);
1438 <        }
1233 <    }
1438 >    }}
1439  
1440      public void testThenAcceptBoth_normalCompletion2() {
1441          for (ExecutionMode m : ExecutionMode.values())
1442          for (Integer v1 : new Integer[] { 1, null })
1443 <        for (Integer v2 : new Integer[] { 2, null }) {
1444 <
1443 >        for (Integer v2 : new Integer[] { 2, null })
1444 >    {
1445          final CompletableFuture<Integer> f = new CompletableFuture<>();
1446          final CompletableFuture<Integer> g = new CompletableFuture<>();
1447          final SubtractAction r = new SubtractAction();
# Line 1248 | Line 1453 | public class CompletableFutureTest exten
1453          f.complete(v1);
1454  
1455          checkCompletedNormally(h, null);
1456 <        assertEquals(r.value, subtract(v1, v2));
1456 >        assertEquals(subtract(v1, v2), r.value);
1457          checkCompletedNormally(f, v1);
1458          checkCompletedNormally(g, v2);
1459 <        }
1255 <    }
1459 >    }}
1460  
1461      public void testThenAcceptBoth_normalCompletion3() {
1462          for (ExecutionMode m : ExecutionMode.values())
1463          for (Integer v1 : new Integer[] { 1, null })
1464 <        for (Integer v2 : new Integer[] { 2, null }) {
1465 <
1464 >        for (Integer v2 : new Integer[] { 2, null })
1465 >    {
1466          final CompletableFuture<Integer> f = new CompletableFuture<>();
1467          final CompletableFuture<Integer> g = new CompletableFuture<>();
1468          final SubtractAction r = new SubtractAction();
# Line 1268 | Line 1472 | public class CompletableFutureTest exten
1472          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1473  
1474          checkCompletedNormally(h, null);
1475 <        assertEquals(r.value, subtract(v1, v2));
1475 >        assertEquals(subtract(v1, v2), r.value);
1476          checkCompletedNormally(f, v1);
1477          checkCompletedNormally(g, v2);
1478 <        }
1275 <    }
1478 >    }}
1479  
1480      public void testThenAcceptBoth_normalCompletion4() {
1481          for (ExecutionMode m : ExecutionMode.values())
1482          for (Integer v1 : new Integer[] { 1, null })
1483 <        for (Integer v2 : new Integer[] { 2, null }) {
1484 <
1483 >        for (Integer v2 : new Integer[] { 2, null })
1484 >    {
1485          final CompletableFuture<Integer> f = new CompletableFuture<>();
1486          final CompletableFuture<Integer> g = new CompletableFuture<>();
1487          final SubtractAction r = new SubtractAction();
# Line 1288 | Line 1491 | public class CompletableFutureTest exten
1491          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1492  
1493          checkCompletedNormally(h, null);
1494 <        assertEquals(r.value, subtract(v1, v2));
1494 >        assertEquals(subtract(v1, v2), r.value);
1495          checkCompletedNormally(f, v1);
1496          checkCompletedNormally(g, v2);
1497 <        }
1295 <    }
1497 >    }}
1498  
1499      /**
1500       * thenAcceptBoth result completes exceptionally after exceptional
# Line 1300 | Line 1502 | public class CompletableFutureTest exten
1502       */
1503      public void testThenAcceptBoth_exceptionalCompletion1() {
1504          for (ExecutionMode m : ExecutionMode.values())
1505 <        for (Integer v1 : new Integer[] { 1, null }) {
1506 <
1505 >        for (Integer v1 : new Integer[] { 1, null })
1506 >    {
1507          final CompletableFuture<Integer> f = new CompletableFuture<>();
1508          final CompletableFuture<Integer> g = new CompletableFuture<>();
1509          final SubtractAction r = new SubtractAction();
# Line 1316 | Line 1518 | public class CompletableFutureTest exten
1518          checkCompletedWithWrappedCFException(f, ex);
1519          assertEquals(0, r.invocationCount);
1520          checkCompletedNormally(g, v1);
1521 <        }
1320 <    }
1521 >    }}
1522  
1523      public void testThenAcceptBoth_exceptionalCompletion2() {
1524          for (ExecutionMode m : ExecutionMode.values())
1525 <        for (Integer v1 : new Integer[] { 1, null }) {
1526 <
1525 >        for (Integer v1 : new Integer[] { 1, null })
1526 >    {
1527          final CompletableFuture<Integer> f = new CompletableFuture<>();
1528          final CompletableFuture<Integer> g = new CompletableFuture<>();
1529          final SubtractAction r = new SubtractAction();
# Line 1337 | Line 1538 | public class CompletableFutureTest exten
1538          checkCompletedWithWrappedCFException(g, ex);
1539          assertEquals(0, r.invocationCount);
1540          checkCompletedNormally(f, v1);
1541 <        }
1341 <    }
1541 >    }}
1542  
1543      public void testThenAcceptBoth_exceptionalCompletion3() {
1544          for (ExecutionMode m : ExecutionMode.values())
1545 <        for (Integer v1 : new Integer[] { 1, null }) {
1546 <
1545 >        for (Integer v1 : new Integer[] { 1, null })
1546 >    {
1547          final CompletableFuture<Integer> f = new CompletableFuture<>();
1548          final CompletableFuture<Integer> g = new CompletableFuture<>();
1549          final SubtractAction r = new SubtractAction();
# Line 1357 | Line 1557 | public class CompletableFutureTest exten
1557          checkCompletedWithWrappedCFException(g, ex);
1558          assertEquals(0, r.invocationCount);
1559          checkCompletedNormally(f, v1);
1560 <        }
1361 <    }
1560 >    }}
1561  
1562      public void testThenAcceptBoth_exceptionalCompletion4() {
1563          for (ExecutionMode m : ExecutionMode.values())
1564 <        for (Integer v1 : new Integer[] { 1, null }) {
1565 <
1564 >        for (Integer v1 : new Integer[] { 1, null })
1565 >    {
1566          final CompletableFuture<Integer> f = new CompletableFuture<>();
1567          final CompletableFuture<Integer> g = new CompletableFuture<>();
1568          final SubtractAction r = new SubtractAction();
# Line 1377 | Line 1576 | public class CompletableFutureTest exten
1576          checkCompletedWithWrappedCFException(f, ex);
1577          assertEquals(0, r.invocationCount);
1578          checkCompletedNormally(g, v1);
1579 <        }
1381 <    }
1579 >    }}
1580  
1581      /**
1582       * thenAcceptBoth result completes exceptionally if action does
# Line 1386 | Line 1584 | public class CompletableFutureTest exten
1584      public void testThenAcceptBoth_actionFailed1() {
1585          for (ExecutionMode m : ExecutionMode.values())
1586          for (Integer v1 : new Integer[] { 1, null })
1587 <        for (Integer v2 : new Integer[] { 2, null }) {
1588 <
1587 >        for (Integer v2 : new Integer[] { 2, null })
1588 >    {
1589          final CompletableFuture<Integer> f = new CompletableFuture<>();
1590          final CompletableFuture<Integer> g = new CompletableFuture<>();
1591          final FailingBiConsumer r = new FailingBiConsumer();
# Line 1400 | Line 1598 | public class CompletableFutureTest exten
1598          checkCompletedWithWrappedCFException(h);
1599          checkCompletedNormally(f, v1);
1600          checkCompletedNormally(g, v2);
1601 <        }
1404 <    }
1601 >    }}
1602  
1603      public void testThenAcceptBoth_actionFailed2() {
1604          for (ExecutionMode m : ExecutionMode.values())
1605          for (Integer v1 : new Integer[] { 1, null })
1606 <        for (Integer v2 : new Integer[] { 2, null }) {
1607 <
1606 >        for (Integer v2 : new Integer[] { 2, null })
1607 >    {
1608          final CompletableFuture<Integer> f = new CompletableFuture<>();
1609          final CompletableFuture<Integer> g = new CompletableFuture<>();
1610          final FailingBiConsumer r = new FailingBiConsumer();
# Line 1420 | Line 1617 | public class CompletableFutureTest exten
1617          checkCompletedWithWrappedCFException(h);
1618          checkCompletedNormally(f, v1);
1619          checkCompletedNormally(g, v2);
1620 <        }
1424 <    }
1620 >    }}
1621  
1622      /**
1623       * thenAcceptBoth result completes exceptionally if either source cancelled
# Line 1429 | Line 1625 | public class CompletableFutureTest exten
1625      public void testThenAcceptBoth_sourceCancelled1() {
1626          for (ExecutionMode m : ExecutionMode.values())
1627          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1628 <        for (Integer v1 : new Integer[] { 1, null }) {
1629 <
1628 >        for (Integer v1 : new Integer[] { 1, null })
1629 >    {
1630          final CompletableFuture<Integer> f = new CompletableFuture<>();
1631          final CompletableFuture<Integer> g = new CompletableFuture<>();
1632          final SubtractAction r = new SubtractAction();
# Line 1444 | Line 1640 | public class CompletableFutureTest exten
1640          checkCancelled(f);
1641          assertEquals(0, r.invocationCount);
1642          checkCompletedNormally(g, v1);
1643 <        }
1448 <    }
1643 >    }}
1644  
1645      public void testThenAcceptBoth_sourceCancelled2() {
1646          for (ExecutionMode m : ExecutionMode.values())
1647          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1648 <        for (Integer v1 : new Integer[] { 1, null }) {
1649 <
1648 >        for (Integer v1 : new Integer[] { 1, null })
1649 >    {
1650          final CompletableFuture<Integer> f = new CompletableFuture<>();
1651          final CompletableFuture<Integer> g = new CompletableFuture<>();
1652          final SubtractAction r = new SubtractAction();
# Line 1465 | Line 1660 | public class CompletableFutureTest exten
1660          checkCancelled(g);
1661          assertEquals(0, r.invocationCount);
1662          checkCompletedNormally(f, v1);
1663 <        }
1469 <    }
1663 >    }}
1664  
1665      public void testThenAcceptBoth_sourceCancelled3() {
1666          for (ExecutionMode m : ExecutionMode.values())
1667          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1668 <        for (Integer v1 : new Integer[] { 1, null }) {
1669 <
1668 >        for (Integer v1 : new Integer[] { 1, null })
1669 >    {
1670          final CompletableFuture<Integer> f = new CompletableFuture<>();
1671          final CompletableFuture<Integer> g = new CompletableFuture<>();
1672          final SubtractAction r = new SubtractAction();
# Line 1485 | Line 1679 | public class CompletableFutureTest exten
1679          checkCancelled(g);
1680          assertEquals(0, r.invocationCount);
1681          checkCompletedNormally(f, v1);
1682 <        }
1489 <    }
1682 >    }}
1683  
1684      public void testThenAcceptBoth_sourceCancelled4() {
1685          for (ExecutionMode m : ExecutionMode.values())
1686          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1687 <        for (Integer v1 : new Integer[] { 1, null }) {
1688 <
1687 >        for (Integer v1 : new Integer[] { 1, null })
1688 >    {
1689          final CompletableFuture<Integer> f = new CompletableFuture<>();
1690          final CompletableFuture<Integer> g = new CompletableFuture<>();
1691          final SubtractAction r = new SubtractAction();
# Line 1505 | Line 1698 | public class CompletableFutureTest exten
1698          checkCancelled(f);
1699          assertEquals(0, r.invocationCount);
1700          checkCompletedNormally(g, v1);
1701 <        }
1509 <    }
1701 >    }}
1702  
1703      /**
1704       * runAfterBoth result completes normally after normal
# Line 1515 | Line 1707 | public class CompletableFutureTest exten
1707      public void testRunAfterBoth_normalCompletion1() {
1708          for (ExecutionMode m : ExecutionMode.values())
1709          for (Integer v1 : new Integer[] { 1, null })
1710 <        for (Integer v2 : new Integer[] { 2, null }) {
1711 <
1710 >        for (Integer v2 : new Integer[] { 2, null })
1711 >    {
1712          final CompletableFuture<Integer> f = new CompletableFuture<>();
1713          final CompletableFuture<Integer> g = new CompletableFuture<>();
1714          final Noop r = new Noop();
# Line 1531 | Line 1723 | public class CompletableFutureTest exten
1723          assertEquals(1, r.invocationCount);
1724          checkCompletedNormally(f, v1);
1725          checkCompletedNormally(g, v2);
1726 <        }
1535 <    }
1726 >    }}
1727  
1728      public void testRunAfterBoth_normalCompletion2() {
1729          for (ExecutionMode m : ExecutionMode.values())
1730          for (Integer v1 : new Integer[] { 1, null })
1731 <        for (Integer v2 : new Integer[] { 2, null }) {
1732 <
1731 >        for (Integer v2 : new Integer[] { 2, null })
1732 >    {
1733          final CompletableFuture<Integer> f = new CompletableFuture<>();
1734          final CompletableFuture<Integer> g = new CompletableFuture<>();
1735          final Noop r = new Noop();
# Line 1553 | Line 1744 | public class CompletableFutureTest exten
1744          assertEquals(1, r.invocationCount);
1745          checkCompletedNormally(f, v1);
1746          checkCompletedNormally(g, v2);
1747 <        }
1557 <    }
1747 >    }}
1748  
1749      public void testRunAfterBoth_normalCompletion3() {
1750          for (ExecutionMode m : ExecutionMode.values())
1751          for (Integer v1 : new Integer[] { 1, null })
1752 <        for (Integer v2 : new Integer[] { 2, null }) {
1753 <
1752 >        for (Integer v2 : new Integer[] { 2, null })
1753 >    {
1754          final CompletableFuture<Integer> f = new CompletableFuture<>();
1755          final CompletableFuture<Integer> g = new CompletableFuture<>();
1756          final Noop r = new Noop();
# Line 1573 | Line 1763 | public class CompletableFutureTest exten
1763          assertEquals(1, r.invocationCount);
1764          checkCompletedNormally(f, v1);
1765          checkCompletedNormally(g, v2);
1766 <        }
1577 <    }
1766 >    }}
1767  
1768      public void testRunAfterBoth_normalCompletion4() {
1769          for (ExecutionMode m : ExecutionMode.values())
1770          for (Integer v1 : new Integer[] { 1, null })
1771 <        for (Integer v2 : new Integer[] { 2, null }) {
1772 <
1771 >        for (Integer v2 : new Integer[] { 2, null })
1772 >    {
1773          final CompletableFuture<Integer> f = new CompletableFuture<>();
1774          final CompletableFuture<Integer> g = new CompletableFuture<>();
1775          final Noop r = new Noop();
# Line 1593 | Line 1782 | public class CompletableFutureTest exten
1782          assertEquals(1, r.invocationCount);
1783          checkCompletedNormally(f, v1);
1784          checkCompletedNormally(g, v2);
1785 <        }
1597 <    }
1785 >    }}
1786  
1787      /**
1788       * runAfterBoth result completes exceptionally after exceptional
# Line 1602 | Line 1790 | public class CompletableFutureTest exten
1790       */
1791      public void testRunAfterBoth_exceptionalCompletion1() {
1792          for (ExecutionMode m : ExecutionMode.values())
1793 <        for (Integer v1 : new Integer[] { 1, null }) {
1794 <
1793 >        for (Integer v1 : new Integer[] { 1, null })
1794 >    {
1795          final CompletableFuture<Integer> f = new CompletableFuture<>();
1796          final CompletableFuture<Integer> g = new CompletableFuture<>();
1797          final Noop r = new Noop();
# Line 1618 | Line 1806 | public class CompletableFutureTest exten
1806          checkCompletedWithWrappedCFException(f, ex);
1807          assertEquals(0, r.invocationCount);
1808          checkCompletedNormally(g, v1);
1809 <        }
1622 <    }
1809 >    }}
1810  
1811      public void testRunAfterBoth_exceptionalCompletion2() {
1812          for (ExecutionMode m : ExecutionMode.values())
1813 <        for (Integer v1 : new Integer[] { 1, null }) {
1814 <
1813 >        for (Integer v1 : new Integer[] { 1, null })
1814 >    {
1815          final CompletableFuture<Integer> f = new CompletableFuture<>();
1816          final CompletableFuture<Integer> g = new CompletableFuture<>();
1817          final Noop r = new Noop();
# Line 1639 | Line 1826 | public class CompletableFutureTest exten
1826          checkCompletedWithWrappedCFException(g, ex);
1827          assertEquals(0, r.invocationCount);
1828          checkCompletedNormally(f, v1);
1829 <        }
1643 <    }
1829 >    }}
1830  
1831      public void testRunAfterBoth_exceptionalCompletion3() {
1832          for (ExecutionMode m : ExecutionMode.values())
1833 <        for (Integer v1 : new Integer[] { 1, null }) {
1834 <
1833 >        for (Integer v1 : new Integer[] { 1, null })
1834 >    {
1835          final CompletableFuture<Integer> f = new CompletableFuture<>();
1836          final CompletableFuture<Integer> g = new CompletableFuture<>();
1837          final Noop r = new Noop();
# Line 1659 | Line 1845 | public class CompletableFutureTest exten
1845          checkCompletedWithWrappedCFException(g, ex);
1846          assertEquals(0, r.invocationCount);
1847          checkCompletedNormally(f, v1);
1848 <        }
1663 <    }
1848 >    }}
1849  
1850      public void testRunAfterBoth_exceptionalCompletion4() {
1851          for (ExecutionMode m : ExecutionMode.values())
1852 <        for (Integer v1 : new Integer[] { 1, null }) {
1853 <
1852 >        for (Integer v1 : new Integer[] { 1, null })
1853 >    {
1854          final CompletableFuture<Integer> f = new CompletableFuture<>();
1855          final CompletableFuture<Integer> g = new CompletableFuture<>();
1856          final Noop r = new Noop();
# Line 1679 | Line 1864 | public class CompletableFutureTest exten
1864          checkCompletedWithWrappedCFException(f, ex);
1865          assertEquals(0, r.invocationCount);
1866          checkCompletedNormally(g, v1);
1867 <        }
1683 <    }
1867 >    }}
1868  
1869      /**
1870       * runAfterBoth result completes exceptionally if action does
# Line 1688 | Line 1872 | public class CompletableFutureTest exten
1872      public void testRunAfterBoth_actionFailed1() {
1873          for (ExecutionMode m : ExecutionMode.values())
1874          for (Integer v1 : new Integer[] { 1, null })
1875 <        for (Integer v2 : new Integer[] { 2, null }) {
1876 <
1875 >        for (Integer v2 : new Integer[] { 2, null })
1876 >    {
1877          final CompletableFuture<Integer> f = new CompletableFuture<>();
1878          final CompletableFuture<Integer> g = new CompletableFuture<>();
1879          final FailingNoop r = new FailingNoop();
# Line 1702 | Line 1886 | public class CompletableFutureTest exten
1886          checkCompletedWithWrappedCFException(h);
1887          checkCompletedNormally(f, v1);
1888          checkCompletedNormally(g, v2);
1889 <        }
1706 <    }
1889 >    }}
1890  
1891      public void testRunAfterBoth_actionFailed2() {
1892          for (ExecutionMode m : ExecutionMode.values())
1893          for (Integer v1 : new Integer[] { 1, null })
1894 <        for (Integer v2 : new Integer[] { 2, null }) {
1895 <
1894 >        for (Integer v2 : new Integer[] { 2, null })
1895 >    {
1896          final CompletableFuture<Integer> f = new CompletableFuture<>();
1897          final CompletableFuture<Integer> g = new CompletableFuture<>();
1898          final FailingNoop r = new FailingNoop();
# Line 1722 | Line 1905 | public class CompletableFutureTest exten
1905          checkCompletedWithWrappedCFException(h);
1906          checkCompletedNormally(f, v1);
1907          checkCompletedNormally(g, v2);
1908 <        }
1726 <    }
1908 >    }}
1909  
1910      /**
1911       * runAfterBoth result completes exceptionally if either source cancelled
# Line 1731 | Line 1913 | public class CompletableFutureTest exten
1913      public void testRunAfterBoth_sourceCancelled1() {
1914          for (ExecutionMode m : ExecutionMode.values())
1915          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1916 <        for (Integer v1 : new Integer[] { 1, null }) {
1917 <
1916 >        for (Integer v1 : new Integer[] { 1, null })
1917 >    {
1918          final CompletableFuture<Integer> f = new CompletableFuture<>();
1919          final CompletableFuture<Integer> g = new CompletableFuture<>();
1920          final Noop r = new Noop();
# Line 1746 | Line 1928 | public class CompletableFutureTest exten
1928          checkCancelled(f);
1929          assertEquals(0, r.invocationCount);
1930          checkCompletedNormally(g, v1);
1931 <        }
1750 <    }
1931 >    }}
1932  
1933      public void testRunAfterBoth_sourceCancelled2() {
1934          for (ExecutionMode m : ExecutionMode.values())
1935          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1936 <        for (Integer v1 : new Integer[] { 1, null }) {
1937 <
1936 >        for (Integer v1 : new Integer[] { 1, null })
1937 >    {
1938          final CompletableFuture<Integer> f = new CompletableFuture<>();
1939          final CompletableFuture<Integer> g = new CompletableFuture<>();
1940          final Noop r = new Noop();
# Line 1767 | Line 1948 | public class CompletableFutureTest exten
1948          checkCancelled(g);
1949          assertEquals(0, r.invocationCount);
1950          checkCompletedNormally(f, v1);
1951 <        }
1771 <    }
1951 >    }}
1952  
1953      public void testRunAfterBoth_sourceCancelled3() {
1954          for (ExecutionMode m : ExecutionMode.values())
1955          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1956 <        for (Integer v1 : new Integer[] { 1, null }) {
1957 <
1956 >        for (Integer v1 : new Integer[] { 1, null })
1957 >    {
1958          final CompletableFuture<Integer> f = new CompletableFuture<>();
1959          final CompletableFuture<Integer> g = new CompletableFuture<>();
1960          final Noop r = new Noop();
# Line 1787 | Line 1967 | public class CompletableFutureTest exten
1967          checkCancelled(g);
1968          assertEquals(0, r.invocationCount);
1969          checkCompletedNormally(f, v1);
1970 <        }
1791 <    }
1970 >    }}
1971  
1972      public void testRunAfterBoth_sourceCancelled4() {
1973          for (ExecutionMode m : ExecutionMode.values())
1974          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1975 <        for (Integer v1 : new Integer[] { 1, null }) {
1976 <
1975 >        for (Integer v1 : new Integer[] { 1, null })
1976 >    {
1977          final CompletableFuture<Integer> f = new CompletableFuture<>();
1978          final CompletableFuture<Integer> g = new CompletableFuture<>();
1979          final Noop r = new Noop();
# Line 1807 | Line 1986 | public class CompletableFutureTest exten
1986          checkCancelled(f);
1987          assertEquals(0, r.invocationCount);
1988          checkCompletedNormally(g, v1);
1989 <        }
1811 <    }
1989 >    }}
1990  
1991      /**
1992       * applyToEither result completes normally after normal completion
# Line 1817 | Line 1995 | public class CompletableFutureTest exten
1995      public void testApplyToEither_normalCompletion1() {
1996          for (ExecutionMode m : ExecutionMode.values())
1997          for (Integer v1 : new Integer[] { 1, null })
1998 <        for (Integer v2 : new Integer[] { 2, null }) {
1999 <
1998 >        for (Integer v2 : new Integer[] { 2, null })
1999 >    {
2000          final CompletableFuture<Integer> f = new CompletableFuture<>();
2001          final CompletableFuture<Integer> g = new CompletableFuture<>();
2002          final IncFunction r = new IncFunction();
# Line 1831 | Line 2009 | public class CompletableFutureTest exten
2009          checkCompletedNormally(f, v1);
2010          checkCompletedNormally(g, v2);
2011          checkCompletedNormally(h, inc(v1));
2012 <        }
1835 <    }
2012 >    }}
2013  
2014      public void testApplyToEither_normalCompletion2() {
2015          for (ExecutionMode m : ExecutionMode.values())
2016          for (Integer v1 : new Integer[] { 1, null })
2017 <        for (Integer v2 : new Integer[] { 2, null }) {
2018 <
2017 >        for (Integer v2 : new Integer[] { 2, null })
2018 >    {
2019          final CompletableFuture<Integer> f = new CompletableFuture<>();
2020          final CompletableFuture<Integer> g = new CompletableFuture<>();
2021          final IncFunction r = new IncFunction();
# Line 1851 | Line 2028 | public class CompletableFutureTest exten
2028          checkCompletedNormally(f, v1);
2029          checkCompletedNormally(g, v2);
2030          checkCompletedNormally(h, inc(v2));
2031 <        }
2032 <    }
2031 >        }}
2032 >
2033      public void testApplyToEither_normalCompletion3() {
2034          for (ExecutionMode m : ExecutionMode.values())
2035          for (Integer v1 : new Integer[] { 1, null })
2036 <        for (Integer v2 : new Integer[] { 2, null }) {
2037 <
2036 >        for (Integer v2 : new Integer[] { 2, null })
2037 >    {
2038          final CompletableFuture<Integer> f = new CompletableFuture<>();
2039          final CompletableFuture<Integer> g = new CompletableFuture<>();
2040          final IncFunction r = new IncFunction();
# Line 1873 | Line 2050 | public class CompletableFutureTest exten
2050          assertTrue(Objects.equals(h.join(), inc(v1)) ||
2051                     Objects.equals(h.join(), inc(v2)));
2052          assertEquals(1, r.invocationCount);
2053 <        }
1877 <    }
2053 >    }}
2054  
2055      /**
2056       * applyToEither result completes exceptionally after exceptional
# Line 1882 | Line 2058 | public class CompletableFutureTest exten
2058       */
2059      public void testApplyToEither_exceptionalCompletion1() {
2060          for (ExecutionMode m : ExecutionMode.values())
2061 <        for (Integer v1 : new Integer[] { 1, null }) {
2062 <
2061 >        for (Integer v1 : new Integer[] { 1, null })
2062 >    {
2063          final CompletableFuture<Integer> f = new CompletableFuture<>();
2064          final CompletableFuture<Integer> g = new CompletableFuture<>();
2065          final IncFunction r = new IncFunction();
# Line 1898 | Line 2074 | public class CompletableFutureTest exten
2074          checkCompletedNormally(g, v1);
2075          checkCompletedWithWrappedCFException(f, ex);
2076          checkCompletedWithWrappedCFException(h, ex);
2077 <        }
1902 <    }
2077 >    }}
2078  
2079      public void testApplyToEither_exceptionalCompletion2() {
2080          for (ExecutionMode m : ExecutionMode.values())
2081 <        for (Integer v1 : new Integer[] { 1, null }) {
2082 <
2081 >        for (Integer v1 : new Integer[] { 1, null })
2082 >    {
2083          final CompletableFuture<Integer> f = new CompletableFuture<>();
2084          final CompletableFuture<Integer> g = new CompletableFuture<>();
2085          final IncFunction r = new IncFunction();
# Line 1919 | Line 2094 | public class CompletableFutureTest exten
2094          checkCompletedNormally(f, v1);
2095          checkCompletedWithWrappedCFException(g, ex);
2096          checkCompletedWithWrappedCFException(h, ex);
2097 <        }
1923 <    }
2097 >    }}
2098  
2099      public void testApplyToEither_exceptionalCompletion3() {
2100          for (ExecutionMode m : ExecutionMode.values())
2101 <        for (Integer v1 : new Integer[] { 1, null }) {
2102 <
2101 >        for (Integer v1 : new Integer[] { 1, null })
2102 >    {
2103          final CompletableFuture<Integer> f = new CompletableFuture<>();
2104          final CompletableFuture<Integer> g = new CompletableFuture<>();
2105          final IncFunction r = new IncFunction();
# Line 1938 | Line 2112 | public class CompletableFutureTest exten
2112          // unspecified behavior
2113          Integer v;
2114          try {
2115 <            assertEquals(h.join(), inc(v1));
2115 >            assertEquals(inc(v1), h.join());
2116              assertEquals(1, r.invocationCount);
2117          } catch (CompletionException ok) {
2118              checkCompletedWithWrappedCFException(h, ex);
# Line 1947 | Line 2121 | public class CompletableFutureTest exten
2121  
2122          checkCompletedWithWrappedCFException(g, ex);
2123          checkCompletedNormally(f, v1);
2124 <        }
1951 <    }
2124 >    }}
2125  
2126      public void testApplyToEither_exceptionalCompletion4() {
2127          for (ExecutionMode m : ExecutionMode.values())
2128 <        for (Integer v1 : new Integer[] { 1, null }) {
2129 <
2128 >        for (Integer v1 : new Integer[] { 1, null })
2129 >    {
2130          final CompletableFuture<Integer> f = new CompletableFuture<>();
2131          final CompletableFuture<Integer> g = new CompletableFuture<>();
2132          final IncFunction r = new IncFunction();
# Line 1966 | Line 2139 | public class CompletableFutureTest exten
2139          // unspecified behavior
2140          Integer v;
2141          try {
2142 <            assertEquals(h.join(), inc(v1));
2142 >            assertEquals(inc(v1), h.join());
2143              assertEquals(1, r.invocationCount);
2144          } catch (CompletionException ok) {
2145              checkCompletedWithWrappedCFException(h, ex);
# Line 1975 | Line 2148 | public class CompletableFutureTest exten
2148  
2149          checkCompletedWithWrappedCFException(f, ex);
2150          checkCompletedNormally(g, v1);
2151 <        }
1979 <    }
2151 >    }}
2152  
2153      /**
2154       * applyToEither result completes exceptionally if action does
# Line 1984 | Line 2156 | public class CompletableFutureTest exten
2156      public void testApplyToEither_actionFailed1() {
2157          for (ExecutionMode m : ExecutionMode.values())
2158          for (Integer v1 : new Integer[] { 1, null })
2159 <        for (Integer v2 : new Integer[] { 2, null }) {
2160 <
2159 >        for (Integer v2 : new Integer[] { 2, null })
2160 >    {
2161          final CompletableFuture<Integer> f = new CompletableFuture<>();
2162          final CompletableFuture<Integer> g = new CompletableFuture<>();
2163          final FailingFunction r = new FailingFunction();
# Line 1996 | Line 2168 | public class CompletableFutureTest exten
2168          g.complete(v2);
2169          checkCompletedNormally(f, v1);
2170          checkCompletedNormally(g, v2);
2171 <        }
2000 <    }
2171 >    }}
2172  
2173      public void testApplyToEither_actionFailed2() {
2174          for (ExecutionMode m : ExecutionMode.values())
2175          for (Integer v1 : new Integer[] { 1, null })
2176 <        for (Integer v2 : new Integer[] { 2, null }) {
2177 <
2176 >        for (Integer v2 : new Integer[] { 2, null })
2177 >    {
2178          final CompletableFuture<Integer> f = new CompletableFuture<>();
2179          final CompletableFuture<Integer> g = new CompletableFuture<>();
2180          final FailingFunction r = new FailingFunction();
# Line 2014 | Line 2185 | public class CompletableFutureTest exten
2185          f.complete(v1);
2186          checkCompletedNormally(f, v1);
2187          checkCompletedNormally(g, v2);
2188 <        }
2018 <    }
2188 >    }}
2189  
2190      /**
2191       * applyToEither result completes exceptionally if either source cancelled
# Line 2023 | Line 2193 | public class CompletableFutureTest exten
2193      public void testApplyToEither_sourceCancelled1() {
2194          for (ExecutionMode m : ExecutionMode.values())
2195          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2196 <        for (Integer v1 : new Integer[] { 1, null }) {
2197 <
2196 >        for (Integer v1 : new Integer[] { 1, null })
2197 >    {
2198          final CompletableFuture<Integer> f = new CompletableFuture<>();
2199          final CompletableFuture<Integer> g = new CompletableFuture<>();
2200          final IncFunction r = new IncFunction();
# Line 2038 | Line 2208 | public class CompletableFutureTest exten
2208          assertEquals(0, r.invocationCount);
2209          checkCompletedNormally(g, v1);
2210          checkCompletedWithWrappedCancellationException(h);
2211 <        }
2042 <    }
2211 >    }}
2212  
2213      public void testApplyToEither_sourceCancelled2() {
2214          for (ExecutionMode m : ExecutionMode.values())
2215          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2216 <        for (Integer v1 : new Integer[] { 1, null }) {
2217 <
2216 >        for (Integer v1 : new Integer[] { 1, null })
2217 >    {
2218          final CompletableFuture<Integer> f = new CompletableFuture<>();
2219          final CompletableFuture<Integer> g = new CompletableFuture<>();
2220          final IncFunction r = new IncFunction();
# Line 2059 | Line 2228 | public class CompletableFutureTest exten
2228          assertEquals(0, r.invocationCount);
2229          checkCompletedNormally(f, v1);
2230          checkCompletedWithWrappedCancellationException(h);
2231 <        }
2063 <    }
2231 >    }}
2232  
2233      public void testApplyToEither_sourceCancelled3() {
2234          for (ExecutionMode m : ExecutionMode.values())
2235          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2236 <        for (Integer v1 : new Integer[] { 1, null }) {
2237 <
2236 >        for (Integer v1 : new Integer[] { 1, null })
2237 >    {
2238          final CompletableFuture<Integer> f = new CompletableFuture<>();
2239          final CompletableFuture<Integer> g = new CompletableFuture<>();
2240          final IncFunction r = new IncFunction();
# Line 2078 | Line 2246 | public class CompletableFutureTest exten
2246          // unspecified behavior
2247          Integer v;
2248          try {
2249 <            assertEquals(h.join(), inc(v1));
2249 >            assertEquals(inc(v1), h.join());
2250              assertEquals(1, r.invocationCount);
2251          } catch (CompletionException ok) {
2252              checkCompletedWithWrappedCancellationException(h);
# Line 2087 | Line 2255 | public class CompletableFutureTest exten
2255  
2256          checkCancelled(g);
2257          checkCompletedNormally(f, v1);
2258 <        }
2091 <    }
2258 >    }}
2259  
2260      public void testApplyToEither_sourceCancelled4() {
2261          for (ExecutionMode m : ExecutionMode.values())
2262          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2263 <        for (Integer v1 : new Integer[] { 1, null }) {
2264 <
2263 >        for (Integer v1 : new Integer[] { 1, null })
2264 >    {
2265          final CompletableFuture<Integer> f = new CompletableFuture<>();
2266          final CompletableFuture<Integer> g = new CompletableFuture<>();
2267          final IncFunction r = new IncFunction();
# Line 2106 | Line 2273 | public class CompletableFutureTest exten
2273          // unspecified behavior
2274          Integer v;
2275          try {
2276 <            assertEquals(h.join(), inc(v1));
2276 >            assertEquals(inc(v1), h.join());
2277              assertEquals(1, r.invocationCount);
2278          } catch (CompletionException ok) {
2279              checkCompletedWithWrappedCancellationException(h);
# Line 2115 | Line 2282 | public class CompletableFutureTest exten
2282  
2283          checkCancelled(f);
2284          checkCompletedNormally(g, v1);
2285 <        }
2119 <    }
2285 >    }}
2286  
2287      /**
2288       * acceptEither result completes normally after normal completion
# Line 2125 | Line 2291 | public class CompletableFutureTest exten
2291      public void testAcceptEither_normalCompletion1() {
2292          for (ExecutionMode m : ExecutionMode.values())
2293          for (Integer v1 : new Integer[] { 1, null })
2294 <        for (Integer v2 : new Integer[] { 2, null }) {
2295 <
2294 >        for (Integer v2 : new Integer[] { 2, null })
2295 >    {
2296          final CompletableFuture<Integer> f = new CompletableFuture<>();
2297          final CompletableFuture<Integer> g = new CompletableFuture<>();
2298          final IncAction r = new IncAction();
# Line 2134 | Line 2300 | public class CompletableFutureTest exten
2300  
2301          f.complete(v1);
2302          checkCompletedNormally(h, null);
2303 <        assertEquals(r.value, inc(v1));
2303 >        assertEquals(inc(v1), r.value);
2304          g.complete(v2);
2305  
2306          checkCompletedNormally(f, v1);
2307          checkCompletedNormally(g, v2);
2308          checkCompletedNormally(h, null);
2309 <        }
2144 <    }
2309 >    }}
2310  
2311      public void testAcceptEither_normalCompletion2() {
2312          for (ExecutionMode m : ExecutionMode.values())
2313          for (Integer v1 : new Integer[] { 1, null })
2314 <        for (Integer v2 : new Integer[] { 2, null }) {
2315 <
2314 >        for (Integer v2 : new Integer[] { 2, null })
2315 >    {
2316          final CompletableFuture<Integer> f = new CompletableFuture<>();
2317          final CompletableFuture<Integer> g = new CompletableFuture<>();
2318          final IncAction r = new IncAction();
# Line 2155 | Line 2320 | public class CompletableFutureTest exten
2320  
2321          g.complete(v2);
2322          checkCompletedNormally(h, null);
2323 <        assertEquals(r.value, inc(v2));
2323 >        assertEquals(inc(v2), r.value);
2324          f.complete(v1);
2325  
2326          checkCompletedNormally(f, v1);
2327          checkCompletedNormally(g, v2);
2328          checkCompletedNormally(h, null);
2329 <        }
2330 <    }
2329 >    }}
2330 >
2331      public void testAcceptEither_normalCompletion3() {
2332          for (ExecutionMode m : ExecutionMode.values())
2333          for (Integer v1 : new Integer[] { 1, null })
2334 <        for (Integer v2 : new Integer[] { 2, null }) {
2335 <
2334 >        for (Integer v2 : new Integer[] { 2, null })
2335 >    {
2336          final CompletableFuture<Integer> f = new CompletableFuture<>();
2337          final CompletableFuture<Integer> g = new CompletableFuture<>();
2338          final IncAction r = new IncAction();
# Line 2183 | Line 2348 | public class CompletableFutureTest exten
2348          // unspecified behavior
2349          assertTrue(Objects.equals(r.value, inc(v1)) ||
2350                     Objects.equals(r.value, inc(v2)));
2351 <        }
2187 <    }
2351 >    }}
2352  
2353      /**
2354       * acceptEither result completes exceptionally after exceptional
# Line 2192 | Line 2356 | public class CompletableFutureTest exten
2356       */
2357      public void testAcceptEither_exceptionalCompletion1() {
2358          for (ExecutionMode m : ExecutionMode.values())
2359 <        for (Integer v1 : new Integer[] { 1, null }) {
2360 <
2359 >        for (Integer v1 : new Integer[] { 1, null })
2360 >    {
2361          final CompletableFuture<Integer> f = new CompletableFuture<>();
2362          final CompletableFuture<Integer> g = new CompletableFuture<>();
2363          final IncAction r = new IncAction();
# Line 2208 | Line 2372 | public class CompletableFutureTest exten
2372          checkCompletedNormally(g, v1);
2373          checkCompletedWithWrappedCFException(f, ex);
2374          checkCompletedWithWrappedCFException(h, ex);
2375 <        }
2212 <    }
2375 >    }}
2376  
2377      public void testAcceptEither_exceptionalCompletion2() {
2378          for (ExecutionMode m : ExecutionMode.values())
2379 <        for (Integer v1 : new Integer[] { 1, null }) {
2380 <
2379 >        for (Integer v1 : new Integer[] { 1, null })
2380 >    {
2381          final CompletableFuture<Integer> f = new CompletableFuture<>();
2382          final CompletableFuture<Integer> g = new CompletableFuture<>();
2383          final IncAction r = new IncAction();
# Line 2229 | Line 2392 | public class CompletableFutureTest exten
2392          checkCompletedNormally(f, v1);
2393          checkCompletedWithWrappedCFException(g, ex);
2394          checkCompletedWithWrappedCFException(h, ex);
2395 <        }
2233 <    }
2395 >    }}
2396  
2397      public void testAcceptEither_exceptionalCompletion3() {
2398          for (ExecutionMode m : ExecutionMode.values())
2399 <        for (Integer v1 : new Integer[] { 1, null }) {
2400 <
2399 >        for (Integer v1 : new Integer[] { 1, null })
2400 >    {
2401          final CompletableFuture<Integer> f = new CompletableFuture<>();
2402          final CompletableFuture<Integer> g = new CompletableFuture<>();
2403          final IncAction r = new IncAction();
# Line 2248 | Line 2410 | public class CompletableFutureTest exten
2410          // unspecified behavior
2411          Integer v;
2412          try {
2413 <            assertEquals(h.join(), null);
2413 >            assertNull(h.join());
2414              assertEquals(1, r.invocationCount);
2415              assertEquals(inc(v1), r.value);
2416          } catch (CompletionException ok) {
# Line 2258 | Line 2420 | public class CompletableFutureTest exten
2420  
2421          checkCompletedWithWrappedCFException(g, ex);
2422          checkCompletedNormally(f, v1);
2423 <        }
2262 <    }
2423 >    }}
2424  
2425      public void testAcceptEither_exceptionalCompletion4() {
2426          for (ExecutionMode m : ExecutionMode.values())
2427 <        for (Integer v1 : new Integer[] { 1, null }) {
2428 <
2427 >        for (Integer v1 : new Integer[] { 1, null })
2428 >    {
2429          final CompletableFuture<Integer> f = new CompletableFuture<>();
2430          final CompletableFuture<Integer> g = new CompletableFuture<>();
2431          final IncAction r = new IncAction();
# Line 2277 | Line 2438 | public class CompletableFutureTest exten
2438          // unspecified behavior
2439          Integer v;
2440          try {
2441 <            assertEquals(h.join(), null);
2441 >            assertNull(h.join());
2442              assertEquals(1, r.invocationCount);
2443              assertEquals(inc(v1), r.value);
2444          } catch (CompletionException ok) {
# Line 2287 | Line 2448 | public class CompletableFutureTest exten
2448  
2449          checkCompletedWithWrappedCFException(f, ex);
2450          checkCompletedNormally(g, v1);
2451 <        }
2291 <    }
2451 >    }}
2452  
2453      /**
2454       * acceptEither result completes exceptionally if action does
# Line 2296 | Line 2456 | public class CompletableFutureTest exten
2456      public void testAcceptEither_actionFailed1() {
2457          for (ExecutionMode m : ExecutionMode.values())
2458          for (Integer v1 : new Integer[] { 1, null })
2459 <        for (Integer v2 : new Integer[] { 2, null }) {
2460 <
2459 >        for (Integer v2 : new Integer[] { 2, null })
2460 >    {
2461          final CompletableFuture<Integer> f = new CompletableFuture<>();
2462          final CompletableFuture<Integer> g = new CompletableFuture<>();
2463          final FailingConsumer r = new FailingConsumer();
# Line 2308 | Line 2468 | public class CompletableFutureTest exten
2468          g.complete(v2);
2469          checkCompletedNormally(f, v1);
2470          checkCompletedNormally(g, v2);
2471 <        }
2312 <    }
2471 >    }}
2472  
2473      public void testAcceptEither_actionFailed2() {
2474          for (ExecutionMode m : ExecutionMode.values())
2475          for (Integer v1 : new Integer[] { 1, null })
2476 <        for (Integer v2 : new Integer[] { 2, null }) {
2477 <
2476 >        for (Integer v2 : new Integer[] { 2, null })
2477 >    {
2478          final CompletableFuture<Integer> f = new CompletableFuture<>();
2479          final CompletableFuture<Integer> g = new CompletableFuture<>();
2480          final FailingConsumer r = new FailingConsumer();
# Line 2326 | Line 2485 | public class CompletableFutureTest exten
2485          f.complete(v1);
2486          checkCompletedNormally(f, v1);
2487          checkCompletedNormally(g, v2);
2488 <        }
2330 <    }
2488 >    }}
2489  
2490      /**
2491       * acceptEither result completes exceptionally if either source cancelled
# Line 2335 | Line 2493 | public class CompletableFutureTest exten
2493      public void testAcceptEither_sourceCancelled1() {
2494          for (ExecutionMode m : ExecutionMode.values())
2495          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2496 <        for (Integer v1 : new Integer[] { 1, null }) {
2497 <
2496 >        for (Integer v1 : new Integer[] { 1, null })
2497 >    {
2498          final CompletableFuture<Integer> f = new CompletableFuture<>();
2499          final CompletableFuture<Integer> g = new CompletableFuture<>();
2500          final IncAction r = new IncAction();
# Line 2350 | Line 2508 | public class CompletableFutureTest exten
2508          assertEquals(0, r.invocationCount);
2509          checkCompletedNormally(g, v1);
2510          checkCompletedWithWrappedCancellationException(h);
2511 <        }
2354 <    }
2511 >    }}
2512  
2513      public void testAcceptEither_sourceCancelled2() {
2514          for (ExecutionMode m : ExecutionMode.values())
2515          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2516 <        for (Integer v1 : new Integer[] { 1, null }) {
2517 <
2516 >        for (Integer v1 : new Integer[] { 1, null })
2517 >    {
2518          final CompletableFuture<Integer> f = new CompletableFuture<>();
2519          final CompletableFuture<Integer> g = new CompletableFuture<>();
2520          final IncAction r = new IncAction();
# Line 2371 | Line 2528 | public class CompletableFutureTest exten
2528          assertEquals(0, r.invocationCount);
2529          checkCompletedNormally(f, v1);
2530          checkCompletedWithWrappedCancellationException(h);
2531 <        }
2375 <    }
2531 >    }}
2532  
2533      public void testAcceptEither_sourceCancelled3() {
2534          for (ExecutionMode m : ExecutionMode.values())
2535          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2536 <        for (Integer v1 : new Integer[] { 1, null }) {
2537 <
2536 >        for (Integer v1 : new Integer[] { 1, null })
2537 >    {
2538          final CompletableFuture<Integer> f = new CompletableFuture<>();
2539          final CompletableFuture<Integer> g = new CompletableFuture<>();
2540          final IncAction r = new IncAction();
# Line 2390 | Line 2546 | public class CompletableFutureTest exten
2546          // unspecified behavior
2547          Integer v;
2548          try {
2549 <            assertEquals(h.join(), null);
2549 >            assertNull(h.join());
2550              assertEquals(1, r.invocationCount);
2551              assertEquals(inc(v1), r.value);
2552          } catch (CompletionException ok) {
# Line 2400 | Line 2556 | public class CompletableFutureTest exten
2556  
2557          checkCancelled(g);
2558          checkCompletedNormally(f, v1);
2559 <        }
2404 <    }
2559 >    }}
2560  
2561      public void testAcceptEither_sourceCancelled4() {
2562          for (ExecutionMode m : ExecutionMode.values())
2563          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2564 <        for (Integer v1 : new Integer[] { 1, null }) {
2565 <
2564 >        for (Integer v1 : new Integer[] { 1, null })
2565 >    {
2566          final CompletableFuture<Integer> f = new CompletableFuture<>();
2567          final CompletableFuture<Integer> g = new CompletableFuture<>();
2568          final IncAction r = new IncAction();
# Line 2419 | Line 2574 | public class CompletableFutureTest exten
2574          // unspecified behavior
2575          Integer v;
2576          try {
2577 <            assertEquals(h.join(), null);
2577 >            assertNull(h.join());
2578              assertEquals(1, r.invocationCount);
2579              assertEquals(inc(v1), r.value);
2580          } catch (CompletionException ok) {
# Line 2429 | Line 2584 | public class CompletableFutureTest exten
2584  
2585          checkCancelled(f);
2586          checkCompletedNormally(g, v1);
2587 <        }
2433 <    }
2587 >    }}
2588  
2589      /**
2590       * runAfterEither result completes normally after normal completion
# Line 2439 | Line 2593 | public class CompletableFutureTest exten
2593      public void testRunAfterEither_normalCompletion1() {
2594          for (ExecutionMode m : ExecutionMode.values())
2595          for (Integer v1 : new Integer[] { 1, null })
2596 <        for (Integer v2 : new Integer[] { 2, null }) {
2597 <
2596 >        for (Integer v2 : new Integer[] { 2, null })
2597 >    {
2598          final CompletableFuture<Integer> f = new CompletableFuture<>();
2599          final CompletableFuture<Integer> g = new CompletableFuture<>();
2600          final Noop r = new Noop();
# Line 2455 | Line 2609 | public class CompletableFutureTest exten
2609          checkCompletedNormally(g, v2);
2610          checkCompletedNormally(h, null);
2611          assertEquals(1, r.invocationCount);
2612 <        }
2459 <    }
2612 >    }}
2613  
2614      public void testRunAfterEither_normalCompletion2() {
2615          for (ExecutionMode m : ExecutionMode.values())
2616          for (Integer v1 : new Integer[] { 1, null })
2617 <        for (Integer v2 : new Integer[] { 2, null }) {
2618 <
2617 >        for (Integer v2 : new Integer[] { 2, null })
2618 >    {
2619          final CompletableFuture<Integer> f = new CompletableFuture<>();
2620          final CompletableFuture<Integer> g = new CompletableFuture<>();
2621          final Noop r = new Noop();
# Line 2477 | Line 2630 | public class CompletableFutureTest exten
2630          checkCompletedNormally(g, v2);
2631          checkCompletedNormally(h, null);
2632          assertEquals(1, r.invocationCount);
2633 <        }
2634 <    }
2633 >        }}
2634 >
2635      public void testRunAfterEither_normalCompletion3() {
2636          for (ExecutionMode m : ExecutionMode.values())
2637          for (Integer v1 : new Integer[] { 1, null })
2638 <        for (Integer v2 : new Integer[] { 2, null }) {
2639 <
2638 >        for (Integer v2 : new Integer[] { 2, null })
2639 >    {
2640          final CompletableFuture<Integer> f = new CompletableFuture<>();
2641          final CompletableFuture<Integer> g = new CompletableFuture<>();
2642          final Noop r = new Noop();
# Line 2496 | Line 2649 | public class CompletableFutureTest exten
2649          checkCompletedNormally(f, v1);
2650          checkCompletedNormally(g, v2);
2651          assertEquals(1, r.invocationCount);
2652 <        }
2500 <    }
2652 >    }}
2653  
2654      /**
2655       * runAfterEither result completes exceptionally after exceptional
# Line 2505 | Line 2657 | public class CompletableFutureTest exten
2657       */
2658      public void testRunAfterEither_exceptionalCompletion1() {
2659          for (ExecutionMode m : ExecutionMode.values())
2660 <        for (Integer v1 : new Integer[] { 1, null }) {
2661 <
2660 >        for (Integer v1 : new Integer[] { 1, null })
2661 >    {
2662          final CompletableFuture<Integer> f = new CompletableFuture<>();
2663          final CompletableFuture<Integer> g = new CompletableFuture<>();
2664          final Noop r = new Noop();
# Line 2521 | Line 2673 | public class CompletableFutureTest exten
2673          checkCompletedNormally(g, v1);
2674          checkCompletedWithWrappedCFException(f, ex);
2675          checkCompletedWithWrappedCFException(h, ex);
2676 <        }
2525 <    }
2676 >    }}
2677  
2678      public void testRunAfterEither_exceptionalCompletion2() {
2679          for (ExecutionMode m : ExecutionMode.values())
2680 <        for (Integer v1 : new Integer[] { 1, null }) {
2681 <
2680 >        for (Integer v1 : new Integer[] { 1, null })
2681 >    {
2682          final CompletableFuture<Integer> f = new CompletableFuture<>();
2683          final CompletableFuture<Integer> g = new CompletableFuture<>();
2684          final Noop r = new Noop();
# Line 2542 | Line 2693 | public class CompletableFutureTest exten
2693          checkCompletedNormally(f, v1);
2694          checkCompletedWithWrappedCFException(g, ex);
2695          checkCompletedWithWrappedCFException(h, ex);
2696 <        }
2546 <    }
2696 >    }}
2697  
2698      public void testRunAfterEither_exceptionalCompletion3() {
2699          for (ExecutionMode m : ExecutionMode.values())
2700 <        for (Integer v1 : new Integer[] { 1, null }) {
2701 <
2700 >        for (Integer v1 : new Integer[] { 1, null })
2701 >    {
2702          final CompletableFuture<Integer> f = new CompletableFuture<>();
2703          final CompletableFuture<Integer> g = new CompletableFuture<>();
2704          final Noop r = new Noop();
# Line 2561 | Line 2711 | public class CompletableFutureTest exten
2711          // unspecified behavior
2712          Integer v;
2713          try {
2714 <            assertEquals(h.join(), null);
2714 >            assertNull(h.join());
2715              assertEquals(1, r.invocationCount);
2716          } catch (CompletionException ok) {
2717              checkCompletedWithWrappedCFException(h, ex);
# Line 2570 | Line 2720 | public class CompletableFutureTest exten
2720  
2721          checkCompletedWithWrappedCFException(g, ex);
2722          checkCompletedNormally(f, v1);
2723 <        }
2574 <    }
2723 >    }}
2724  
2725      public void testRunAfterEither_exceptionalCompletion4() {
2726          for (ExecutionMode m : ExecutionMode.values())
2727 <        for (Integer v1 : new Integer[] { 1, null }) {
2728 <
2727 >        for (Integer v1 : new Integer[] { 1, null })
2728 >    {
2729          final CompletableFuture<Integer> f = new CompletableFuture<>();
2730          final CompletableFuture<Integer> g = new CompletableFuture<>();
2731          final Noop r = new Noop();
# Line 2589 | Line 2738 | public class CompletableFutureTest exten
2738          // unspecified behavior
2739          Integer v;
2740          try {
2741 <            assertEquals(h.join(), null);
2741 >            assertNull(h.join());
2742              assertEquals(1, r.invocationCount);
2743          } catch (CompletionException ok) {
2744              checkCompletedWithWrappedCFException(h, ex);
# Line 2598 | Line 2747 | public class CompletableFutureTest exten
2747  
2748          checkCompletedWithWrappedCFException(f, ex);
2749          checkCompletedNormally(g, v1);
2750 <        }
2602 <    }
2750 >    }}
2751  
2752      /**
2753       * runAfterEither result completes exceptionally if action does
# Line 2607 | Line 2755 | public class CompletableFutureTest exten
2755      public void testRunAfterEither_actionFailed1() {
2756          for (ExecutionMode m : ExecutionMode.values())
2757          for (Integer v1 : new Integer[] { 1, null })
2758 <        for (Integer v2 : new Integer[] { 2, null }) {
2759 <
2758 >        for (Integer v2 : new Integer[] { 2, null })
2759 >    {
2760          final CompletableFuture<Integer> f = new CompletableFuture<>();
2761          final CompletableFuture<Integer> g = new CompletableFuture<>();
2762          final FailingNoop r = new FailingNoop();
# Line 2619 | Line 2767 | public class CompletableFutureTest exten
2767          g.complete(v2);
2768          checkCompletedNormally(f, v1);
2769          checkCompletedNormally(g, v2);
2770 <        }
2623 <    }
2770 >    }}
2771  
2772      public void testRunAfterEither_actionFailed2() {
2773          for (ExecutionMode m : ExecutionMode.values())
2774          for (Integer v1 : new Integer[] { 1, null })
2775 <        for (Integer v2 : new Integer[] { 2, null }) {
2776 <
2775 >        for (Integer v2 : new Integer[] { 2, null })
2776 >    {
2777          final CompletableFuture<Integer> f = new CompletableFuture<>();
2778          final CompletableFuture<Integer> g = new CompletableFuture<>();
2779          final FailingNoop r = new FailingNoop();
# Line 2637 | Line 2784 | public class CompletableFutureTest exten
2784          f.complete(v1);
2785          checkCompletedNormally(f, v1);
2786          checkCompletedNormally(g, v2);
2787 <        }
2641 <    }
2787 >    }}
2788  
2789      /**
2790       * runAfterEither result completes exceptionally if either source cancelled
# Line 2646 | Line 2792 | public class CompletableFutureTest exten
2792      public void testRunAfterEither_sourceCancelled1() {
2793          for (ExecutionMode m : ExecutionMode.values())
2794          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2795 <        for (Integer v1 : new Integer[] { 1, null }) {
2796 <
2795 >        for (Integer v1 : new Integer[] { 1, null })
2796 >    {
2797          final CompletableFuture<Integer> f = new CompletableFuture<>();
2798          final CompletableFuture<Integer> g = new CompletableFuture<>();
2799          final Noop r = new Noop();
# Line 2661 | Line 2807 | public class CompletableFutureTest exten
2807          assertEquals(0, r.invocationCount);
2808          checkCompletedNormally(g, v1);
2809          checkCompletedWithWrappedCancellationException(h);
2810 <        }
2665 <    }
2810 >    }}
2811  
2812      public void testRunAfterEither_sourceCancelled2() {
2813          for (ExecutionMode m : ExecutionMode.values())
2814          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2815 <        for (Integer v1 : new Integer[] { 1, null }) {
2816 <
2815 >        for (Integer v1 : new Integer[] { 1, null })
2816 >    {
2817          final CompletableFuture<Integer> f = new CompletableFuture<>();
2818          final CompletableFuture<Integer> g = new CompletableFuture<>();
2819          final Noop r = new Noop();
# Line 2682 | Line 2827 | public class CompletableFutureTest exten
2827          assertEquals(0, r.invocationCount);
2828          checkCompletedNormally(f, v1);
2829          checkCompletedWithWrappedCancellationException(h);
2830 <        }
2686 <    }
2830 >    }}
2831  
2832      public void testRunAfterEither_sourceCancelled3() {
2833          for (ExecutionMode m : ExecutionMode.values())
2834          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2835 <        for (Integer v1 : new Integer[] { 1, null }) {
2836 <
2835 >        for (Integer v1 : new Integer[] { 1, null })
2836 >    {
2837          final CompletableFuture<Integer> f = new CompletableFuture<>();
2838          final CompletableFuture<Integer> g = new CompletableFuture<>();
2839          final Noop r = new Noop();
# Line 2701 | Line 2845 | public class CompletableFutureTest exten
2845          // unspecified behavior
2846          Integer v;
2847          try {
2848 <            assertEquals(h.join(), null);
2848 >            assertNull(h.join());
2849              assertEquals(1, r.invocationCount);
2850          } catch (CompletionException ok) {
2851              checkCompletedWithWrappedCancellationException(h);
# Line 2710 | Line 2854 | public class CompletableFutureTest exten
2854  
2855          checkCancelled(g);
2856          checkCompletedNormally(f, v1);
2857 <        }
2714 <    }
2857 >    }}
2858  
2859      public void testRunAfterEither_sourceCancelled4() {
2860          for (ExecutionMode m : ExecutionMode.values())
2861          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2862 <        for (Integer v1 : new Integer[] { 1, null }) {
2863 <
2862 >        for (Integer v1 : new Integer[] { 1, null })
2863 >    {
2864          final CompletableFuture<Integer> f = new CompletableFuture<>();
2865          final CompletableFuture<Integer> g = new CompletableFuture<>();
2866          final Noop r = new Noop();
# Line 2729 | Line 2872 | public class CompletableFutureTest exten
2872          // unspecified behavior
2873          Integer v;
2874          try {
2875 <            assertEquals(h.join(), null);
2875 >            assertNull(h.join());
2876              assertEquals(1, r.invocationCount);
2877          } catch (CompletionException ok) {
2878              checkCompletedWithWrappedCancellationException(h);
# Line 2738 | Line 2881 | public class CompletableFutureTest exten
2881  
2882          checkCancelled(f);
2883          checkCompletedNormally(g, v1);
2884 <        }
2742 <    }
2884 >    }}
2885  
2886      /**
2887       * thenCompose result completes normally after normal completion of source
2888       */
2889 <    public void testThenCompose_normalCompletion1() {
2889 >    public void testThenCompose_normalCompletion() {
2890          for (ExecutionMode m : ExecutionMode.values())
2891 <        for (Integer v1 : new Integer[] { 1, null }) {
2892 <
2891 >        for (boolean createIncomplete : new boolean[] { true, false })
2892 >        for (Integer v1 : new Integer[] { 1, null })
2893 >    {
2894          final CompletableFuture<Integer> f = new CompletableFuture<>();
2895          final CompletableFutureInc r = new CompletableFutureInc();
2896 +        if (!createIncomplete) f.complete(v1);
2897          final CompletableFuture<Integer> g = f.thenCompose(r);
2898 <        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 }) {
2898 >        if (createIncomplete) f.complete(v1);
2899  
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);
2900          checkCompletedNormally(g, inc(v1));
2901          checkCompletedNormally(f, v1);
2902          assertEquals(1, r.invocationCount);
2903 <        }
2773 <    }
2903 >    }}
2904  
2905      /**
2906       * thenCompose result completes exceptionally after exceptional
2907       * completion of source
2908       */
2909 <    public void testThenCompose_exceptionalCompletion1() {
2910 <        for (ExecutionMode m : ExecutionMode.values()) {
2911 <
2909 >    public void testThenCompose_exceptionalCompletion() {
2910 >        for (ExecutionMode m : ExecutionMode.values())
2911 >        for (boolean createIncomplete : new boolean[] { true, false })
2912 >    {
2913          final CFException ex = new CFException();
2914          final CompletableFutureInc r = new CompletableFutureInc();
2915          final CompletableFuture<Integer> f = new CompletableFuture<>();
2916 +        if (!createIncomplete) f.completeExceptionally(ex);
2917          final CompletableFuture<Integer> g = f.thenCompose(r);
2918 <        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()) {
2918 >        if (createIncomplete) f.completeExceptionally(ex);
2919  
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);
2920          checkCompletedWithWrappedCFException(g, ex);
2921          checkCompletedWithWrappedCFException(f, ex);
2922 <        }
2923 <    }
2922 >        assertEquals(0, r.invocationCount);
2923 >    }}
2924  
2925      /**
2926       * thenCompose result completes exceptionally if action does
2927       */
2928 <    public void testThenCompose_actionFailed1() {
2928 >    public void testThenCompose_actionFailed() {
2929          for (ExecutionMode m : ExecutionMode.values())
2930 <        for (Integer v1 : new Integer[] { 1, null }) {
2931 <
2930 >        for (boolean createIncomplete : new boolean[] { true, false })
2931 >        for (Integer v1 : new Integer[] { 1, null })
2932 >    {
2933          final CompletableFuture<Integer> f = new CompletableFuture<>();
2934          final FailingCompletableFutureFunction r
2935              = new FailingCompletableFutureFunction();
2936 +        if (!createIncomplete) f.complete(v1);
2937          final CompletableFuture<Integer> g = f.thenCompose(r);
2938 <        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 }) {
2938 >        if (createIncomplete) f.complete(v1);
2939  
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);
2940          checkCompletedWithWrappedCFException(g);
2941          checkCompletedNormally(f, v1);
2942 <        }
2834 <    }
2942 >    }}
2943  
2944      /**
2945       * thenCompose result completes exceptionally if source cancelled
2946       */
2947 <    public void testThenCompose_sourceCancelled1() {
2947 >    public void testThenCompose_sourceCancelled() {
2948          for (ExecutionMode m : ExecutionMode.values())
2949 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
2950 <
2949 >        for (boolean createIncomplete : new boolean[] { true, false })
2950 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2951 >    {
2952          final CompletableFuture<Integer> f = new CompletableFuture<>();
2953          final CompletableFutureInc r = new CompletableFutureInc();
2954 +        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2955          final CompletableFuture<Integer> g = f.thenCompose(r);
2956 <        assertTrue(f.cancel(mayInterruptIfRunning));
2847 <        checkCompletedWithWrappedCancellationException(g);
2848 <        checkCancelled(f);
2849 <        }
2850 <    }
2956 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2957  
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);
2958          checkCompletedWithWrappedCancellationException(g);
2959          checkCancelled(f);
2960 <        }
2863 <    }
2960 >    }}
2961  
2962      // asyncs
2963  
2964      /**
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 –    /**
2965       * thenAcceptAsync result completes normally after normal
2966       * completion of source
2967       */
# Line 3012 | Line 3011 | public class CompletableFutureTest exten
3011      // async with explicit executors
3012  
3013      /**
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 –    /**
3014       * thenAcceptAsync result completes normally after normal
3015       * completion of source
3016       */
# Line 3355 | Line 3256 | public class CompletableFutureTest exten
3256       * source result.
3257       */
3258      public void testWhenComplete_normalCompletion1() {
3358 –        for (boolean createIncomplete : new boolean[] { true, false })
3259          for (ExecutionMode m : ExecutionMode.values())
3260 <        for (Integer v1 : new Integer[] { 1, null }) {
3261 <
3262 <        final AtomicInteger a = new AtomicInteger();
3260 >        for (boolean createIncomplete : new boolean[] { true, false })
3261 >        for (Integer v1 : new Integer[] { 1, null })
3262 >    {
3263 >        final AtomicInteger a = new AtomicInteger(0);
3264          final CompletableFuture<Integer> f = new CompletableFuture<>();
3265          if (!createIncomplete) f.complete(v1);
3266 <        final CompletableFuture<Integer> g =
3267 <            m.whenComplete(f,
3268 <                           (Integer x, Throwable t) -> {
3269 <                               threadAssertSame(x, v1);
3270 <                               threadAssertNull(t);
3271 <                               a.getAndIncrement();
3272 <                           });
3266 >        final CompletableFuture<Integer> g = m.whenComplete
3267 >            (f,
3268 >             (Integer x, Throwable t) -> {
3269 >                threadAssertSame(x, v1);
3270 >                threadAssertNull(t);
3271 >                a.getAndIncrement();
3272 >            });
3273          if (createIncomplete) f.complete(v1);
3274 <        checkCompletedNormally(f, v1);
3274 >
3275          checkCompletedNormally(g, v1);
3276 <        assertEquals(a.get(), 1);
3277 <        }
3278 <    }
3276 >        checkCompletedNormally(f, v1);
3277 >        assertEquals(1, a.get());
3278 >    }}
3279  
3280      /**
3281       * whenComplete action executes on exceptional completion, propagating
3282       * source result.
3283       */
3284      public void testWhenComplete_exceptionalCompletion() {
3384 –        for (boolean createIncomplete : new boolean[] { true, false })
3285          for (ExecutionMode m : ExecutionMode.values())
3286 <        for (Integer v1 : new Integer[] { 1, null }) {
3287 <
3288 <        final AtomicInteger a = new AtomicInteger();
3286 >        for (boolean createIncomplete : new boolean[] { true, false })
3287 >        for (Integer v1 : new Integer[] { 1, null })
3288 >    {
3289 >        final AtomicInteger a = new AtomicInteger(0);
3290          final CFException ex = new CFException();
3291          final CompletableFuture<Integer> f = new CompletableFuture<>();
3292          if (!createIncomplete) f.completeExceptionally(ex);
# Line 3399 | Line 3300 | public class CompletableFutureTest exten
3300          if (createIncomplete) f.completeExceptionally(ex);
3301          checkCompletedWithWrappedCFException(f, ex);
3302          checkCompletedWithWrappedCFException(g, ex);
3303 <        assertEquals(a.get(), 1);
3304 <        }
3305 <    }
3303 >        assertEquals(1, a.get());
3304 >    }}
3305 >
3306 >    /**
3307 >     * whenComplete action executes on cancelled source, propagating
3308 >     * CancellationException.
3309 >     */
3310 >    public void testWhenComplete_sourceCancelled() {
3311 >        for (ExecutionMode m : ExecutionMode.values())
3312 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3313 >        for (boolean createIncomplete : new boolean[] { true, false })
3314 >    {
3315 >        final AtomicInteger a = new AtomicInteger(0);
3316 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3317 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3318 >        final CompletableFuture<Integer> g = m.whenComplete
3319 >            (f,
3320 >             (Integer x, Throwable t) -> {
3321 >                threadAssertNull(x);
3322 >                threadAssertTrue(t instanceof CancellationException);
3323 >                a.getAndIncrement();
3324 >            });
3325 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3326 >
3327 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
3328 >        checkCompletedWithWrappedCancellationException(g);
3329 >        checkCancelled(f);
3330 >        assertEquals(1, a.get());
3331 >    }}
3332  
3333      /**
3334       * If a whenComplete action throws an exception when triggered by
# Line 3410 | Line 3337 | public class CompletableFutureTest exten
3337      public void testWhenComplete_actionFailed() {
3338          for (boolean createIncomplete : new boolean[] { true, false })
3339          for (ExecutionMode m : ExecutionMode.values())
3340 <        for (Integer v1 : new Integer[] { 1, null }) {
3341 <
3340 >        for (Integer v1 : new Integer[] { 1, null })
3341 >    {
3342 >        final AtomicInteger a = new AtomicInteger(0);
3343          final CFException ex = new CFException();
3344          final CompletableFuture<Integer> f = new CompletableFuture<>();
3345          if (!createIncomplete) f.complete(v1);
# Line 3420 | Line 3348 | public class CompletableFutureTest exten
3348               (Integer x, Throwable t) -> {
3349                  threadAssertSame(x, v1);
3350                  threadAssertNull(t);
3351 +                a.getAndIncrement();
3352                  throw ex;
3353              });
3354          if (createIncomplete) f.complete(v1);
3355          checkCompletedNormally(f, v1);
3356          checkCompletedWithWrappedCFException(g, ex);
3357 <        }
3358 <    }
3357 >        assertEquals(1, a.get());
3358 >    }}
3359  
3360      /**
3361       * If a whenComplete action throws an exception when triggered by
# Line 3436 | Line 3365 | public class CompletableFutureTest exten
3365      public void testWhenComplete_actionFailedSourceFailed() {
3366          for (boolean createIncomplete : new boolean[] { true, false })
3367          for (ExecutionMode m : ExecutionMode.values())
3368 <        for (Integer v1 : new Integer[] { 1, null }) {
3369 <
3368 >        for (Integer v1 : new Integer[] { 1, null })
3369 >    {
3370 >        final AtomicInteger a = new AtomicInteger(0);
3371          final CFException ex1 = new CFException();
3372          final CFException ex2 = new CFException();
3373          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3448 | Line 3378 | public class CompletableFutureTest exten
3378               (Integer x, Throwable t) -> {
3379                  threadAssertSame(t, ex1);
3380                  threadAssertNull(x);
3381 +                a.getAndIncrement();
3382                  throw ex2;
3383              });
3384          if (createIncomplete) f.completeExceptionally(ex1);
3385  
3386          checkCompletedWithWrappedCFException(f, ex1);
3387          checkCompletedWithWrappedCFException(g, ex1);
3388 <        }
3389 <    }
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 <    }
3388 >        assertEquals(1, a.get());
3389 >    }}
3390  
3391   }

Diff Legend

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