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.22 by jsr166, Mon Apr 8 20:46:59 2013 UTC vs.
Revision 1.37 by jsr166, Sun Jun 1 23:20:19 2014 UTC

# Line 16 | Line 16 | import java.util.concurrent.ExecutionExc
16   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.TimeoutException;
21   import java.util.concurrent.atomic.AtomicInteger;
22   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 68 | Line 69 | public class CompletableFutureTest exten
69          } catch (Throwable fail) { threadUnexpectedException(fail); }
70          assertTrue(f.isDone());
71          assertFalse(f.isCancelled());
72 +        assertFalse(f.isCompletedExceptionally());
73          assertTrue(f.toString().contains("[Completed normally]"));
74      }
75  
# Line 101 | Line 103 | public class CompletableFutureTest exten
103          assertTrue(f.toString().contains("[Completed exceptionally]"));
104      }
105  
106 +    void checkCompletedWithWrappedCFException(CompletableFuture<?> f,
107 +                                              CFException ex) {
108 +        try {
109 +            f.get(LONG_DELAY_MS, MILLISECONDS);
110 +            shouldThrow();
111 +        } catch (ExecutionException success) {
112 +            assertSame(ex, success.getCause());
113 +        } catch (Throwable fail) { threadUnexpectedException(fail); }
114 +        try {
115 +            f.join();
116 +            shouldThrow();
117 +        } catch (CompletionException success) {
118 +            assertSame(ex, success.getCause());
119 +        }
120 +        try {
121 +            f.getNow(null);
122 +            shouldThrow();
123 +        } catch (CompletionException success) {
124 +            assertSame(ex, success.getCause());
125 +        }
126 +        try {
127 +            f.get();
128 +            shouldThrow();
129 +        } catch (ExecutionException success) {
130 +            assertSame(ex, success.getCause());
131 +        } catch (Throwable fail) { threadUnexpectedException(fail); }
132 +        assertTrue(f.isDone());
133 +        assertFalse(f.isCancelled());
134 +        assertTrue(f.toString().contains("[Completed exceptionally]"));
135 +    }
136 +
137      void checkCancelled(CompletableFuture<?> f) {
138          try {
139              f.get(LONG_DELAY_MS, MILLISECONDS);
# Line 121 | Line 154 | public class CompletableFutureTest exten
154          } catch (CancellationException success) {
155          } catch (Throwable fail) { threadUnexpectedException(fail); }
156          assertTrue(f.isDone());
157 +        assertTrue(f.isCompletedExceptionally());
158          assertTrue(f.isCancelled());
159          assertTrue(f.toString().contains("[Completed exceptionally]"));
160      }
# Line 152 | Line 186 | public class CompletableFutureTest exten
186          } catch (Throwable fail) { threadUnexpectedException(fail); }
187          assertTrue(f.isDone());
188          assertFalse(f.isCancelled());
189 +        assertTrue(f.isCompletedExceptionally());
190          assertTrue(f.toString().contains("[Completed exceptionally]"));
191      }
192  
# Line 256 | Line 291 | public class CompletableFutureTest exten
291          assertEquals(g.getNumberOfDependents(), 0);
292      }
293  
259
294      /**
295       * toString indicates current completion state
296       */
# Line 284 | Line 318 | public class CompletableFutureTest exten
318  
319      // Choose non-commutative actions for better coverage
320  
321 +    // A non-commutative function that handles null values as well,
322 +    // and produces null values occasionally.
323 +    public static Integer subtract(Integer x, Integer y) {
324 +        return (x == null && y == null) ? null :
325 +            ((x == null) ? 42 : x.intValue())
326 +            - ((y == null) ? 99 : y.intValue());
327 +    }
328 +
329      static final Supplier<Integer> supplyOne =
330          () -> Integer.valueOf(1);
331      static final Function<Integer, Integer> inc =
332          (Integer x) -> Integer.valueOf(x.intValue() + 1);
333      static final BiFunction<Integer, Integer, Integer> subtract =
334 <        (Integer x, Integer y) -> Integer.valueOf(x.intValue() - y.intValue());
334 >        (Integer x, Integer y) -> subtract(x, y);
335      static final class IncAction implements Consumer<Integer> {
336          int value;
337          public void accept(Integer x) { value = x.intValue() + 1; }
338      }
339      static final class SubtractAction implements BiConsumer<Integer, Integer> {
340 <        int value;
340 >        int invocationCount = 0;
341 >        Integer value;
342 >        // Check this action was invoked exactly once when result is computed.
343 >        public boolean ran() { return invocationCount == 1; }
344          public void accept(Integer x, Integer y) {
345 <            value = x.intValue() - y.intValue();
345 >            invocationCount++;
346 >            value = subtract(x, y);
347 >        }
348 >    }
349 >    static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
350 >        int invocationCount = 0;
351 >        Integer value;
352 >        // Check this action was invoked exactly once when result is computed.
353 >        public boolean ran() { return invocationCount == 1; }
354 >        public Integer apply(Integer x, Integer y) {
355 >            invocationCount++;
356 >            return value = subtract(x, y);
357          }
358      }
359      static final class Noop implements Runnable {
# Line 371 | Line 427 | public class CompletableFutureTest exten
427          }
428      }
429  
430 +    /**
431 +     * Permits the testing of parallel code for the 3 different
432 +     * execution modes without repeating all the testing code.
433 +     */
434 +    enum ExecutionMode {
435 +        DEFAULT {
436 +            public <T,U> CompletableFuture<Void> runAfterBoth
437 +                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
438 +                return f.runAfterBoth(g, a);
439 +            }
440 +            public <T,U> CompletableFuture<Void> thenAcceptBoth
441 +                (CompletableFuture<T> f,
442 +                 CompletionStage<? extends U> g,
443 +                 BiConsumer<? super T,? super U> a) {
444 +                return f.thenAcceptBoth(g, a);
445 +            }
446 +            public <T,U,V> CompletableFuture<V> thenCombine
447 +                (CompletableFuture<T> f,
448 +                 CompletionStage<? extends U> g,
449 +                 BiFunction<? super T,? super U,? extends V> a) {
450 +                return f.thenCombine(g, a);
451 +            }
452 +        },
453 +
454 + //             /** Experimental way to do more testing */
455 + //         REVERSE_DEFAULT {
456 + //             public <T,U> CompletableFuture<Void> runAfterBoth
457 + //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
458 + //                 return g.runAfterBoth(f, a);
459 + //             }
460 + //             public <T,U> CompletableFuture<Void> thenAcceptBoth
461 + //                 (CompletableFuture<T> f,
462 + //                  CompletionStage<? extends U> g,
463 + //                  BiConsumer<? super T,? super U> a) {
464 + //                 return DEFAULT.thenAcceptBoth(f, g, a);
465 + //             }
466 + //         },
467 +
468 +        DEFAULT_ASYNC {
469 +            public <T,U> CompletableFuture<Void> runAfterBoth
470 +                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
471 +                return f.runAfterBothAsync(g, a);
472 +            }
473 +            public <T,U> CompletableFuture<Void> thenAcceptBoth
474 +                (CompletableFuture<T> f,
475 +                 CompletionStage<? extends U> g,
476 +                 BiConsumer<? super T,? super U> a) {
477 +                return f.thenAcceptBothAsync(g, a);
478 +            }
479 +            public <T,U,V> CompletableFuture<V> thenCombine
480 +                (CompletableFuture<T> f,
481 +                 CompletionStage<? extends U> g,
482 +                 BiFunction<? super T,? super U,? extends V> a) {
483 +                return f.thenCombineAsync(g, a);
484 +            }
485 +        },
486 +
487 + //         REVERSE_DEFAULT_ASYNC {
488 + //             public <T,U> CompletableFuture<Void> runAfterBoth
489 + //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
490 + //                 return f.runAfterBothAsync(g, a);
491 + //             }
492 + //             public <T,U> CompletableFuture<Void> thenAcceptBoth
493 + //                 (CompletableFuture<T> f,
494 + //                  CompletionStage<? extends U> g,
495 + //                  BiConsumer<? super T,? super U> a) {
496 + //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
497 + //             }
498 + //         },
499 +
500 +        EXECUTOR {
501 +            public <T,U> CompletableFuture<Void> runAfterBoth
502 +                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
503 +                return f.runAfterBothAsync(g, a, new ThreadExecutor());
504 +            }
505 +            public <T,U> CompletableFuture<Void> thenAcceptBoth
506 +                (CompletableFuture<T> f,
507 +                 CompletionStage<? extends U> g,
508 +                 BiConsumer<? super T,? super U> a) {
509 +                return f.thenAcceptBothAsync(g, a, new ThreadExecutor());
510 +            }
511 +            public <T,U,V> CompletableFuture<V> thenCombine
512 +                (CompletableFuture<T> f,
513 +                 CompletionStage<? extends U> g,
514 +                 BiFunction<? super T,? super U,? extends V> a) {
515 +                return f.thenCombineAsync(g, a, new ThreadExecutor());
516 +            }
517 +        };
518 +
519 +        public abstract <T,U> CompletableFuture<Void> runAfterBoth
520 +            (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
521 +        public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
522 +            (CompletableFuture<T> f,
523 +             CompletionStage<? extends U> g,
524 +             BiConsumer<? super T,? super U> a);
525 +        public abstract <T,U,V> CompletableFuture<V> thenCombine
526 +            (CompletableFuture<T> f,
527 +             CompletionStage<? extends U> g,
528 +             BiFunction<? super T,? super U,? extends V> a);
529 +    }
530  
531      /**
532       * exceptionally action completes with function value on source
533 <     * exception;  otherwise with source value
533 >     * exception; otherwise with source value
534       */
535      public void testExceptionally() {
536          CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 495 | Line 651 | public class CompletableFutureTest exten
651       * thenRun result completes normally after normal completion of source
652       */
653      public void testThenRun() {
654 <        CompletableFuture<Integer> f = new CompletableFuture<>();
655 <        Noop r = new Noop();
656 <        CompletableFuture<Void> g = f.thenRun(r);
654 >        CompletableFuture<Integer> f;
655 >        CompletableFuture<Void> g;
656 >        Noop r;
657 >
658 >        f = new CompletableFuture<>();
659 >        g = f.thenRun(r = new Noop());
660          f.complete(null);
661          checkCompletedNormally(g, null);
662 <        // reordered version
662 >        assertTrue(r.ran);
663 >
664          f = new CompletableFuture<>();
665          f.complete(null);
666 <        r = new Noop();
507 <        g = f.thenRun(r);
666 >        g = f.thenRun(r = new Noop());
667          checkCompletedNormally(g, null);
668 +        assertTrue(r.ran);
669      }
670  
671      /**
# Line 513 | Line 673 | public class CompletableFutureTest exten
673       * completion of source
674       */
675      public void testThenRun2() {
676 <        CompletableFuture<Integer> f = new CompletableFuture<>();
677 <        Noop r = new Noop();
678 <        CompletableFuture<Void> g = f.thenRun(r);
676 >        CompletableFuture<Integer> f;
677 >        CompletableFuture<Void> g;
678 >        Noop r;
679 >
680 >        f = new CompletableFuture<>();
681 >        g = f.thenRun(r = new Noop());
682          f.completeExceptionally(new CFException());
683          checkCompletedWithWrappedCFException(g);
684 +        assertFalse(r.ran);
685 +
686 +        f = new CompletableFuture<>();
687 +        f.completeExceptionally(new CFException());
688 +        g = f.thenRun(r = new Noop());
689 +        checkCompletedWithWrappedCFException(g);
690 +        assertFalse(r.ran);
691      }
692  
693      /**
694       * thenRun result completes exceptionally if action does
695       */
696      public void testThenRun3() {
697 <        CompletableFuture<Integer> f = new CompletableFuture<>();
698 <        FailingNoop r = new FailingNoop();
699 <        CompletableFuture<Void> g = f.thenRun(r);
697 >        CompletableFuture<Integer> f;
698 >        CompletableFuture<Void> g;
699 >        FailingNoop r;
700 >
701 >        f = new CompletableFuture<>();
702 >        g = f.thenRun(r = new FailingNoop());
703 >        f.complete(null);
704 >        checkCompletedWithWrappedCFException(g);
705 >
706 >        f = new CompletableFuture<>();
707          f.complete(null);
708 +        g = f.thenRun(r = new FailingNoop());
709          checkCompletedWithWrappedCFException(g);
710      }
711  
# Line 535 | Line 713 | public class CompletableFutureTest exten
713       * thenRun result completes exceptionally if source cancelled
714       */
715      public void testThenRun4() {
716 <        CompletableFuture<Integer> f = new CompletableFuture<>();
717 <        Noop r = new Noop();
718 <        CompletableFuture<Void> g = f.thenRun(r);
716 >        CompletableFuture<Integer> f;
717 >        CompletableFuture<Void> g;
718 >        Noop r;
719 >
720 >        f = new CompletableFuture<>();
721 >        g = f.thenRun(r = new Noop());
722          assertTrue(f.cancel(true));
723          checkCompletedWithWrappedCancellationException(g);
724 +
725 +        f = new CompletableFuture<>();
726 +        assertTrue(f.cancel(true));
727 +        g = f.thenRun(r = new Noop());
728 +        checkCompletedWithWrappedCancellationException(g);
729      }
730  
731      /**
# Line 630 | Line 816 | public class CompletableFutureTest exten
816          checkCompletedWithWrappedCancellationException(g);
817      }
818  
633
819      /**
820       * thenCombine result completes normally after normal completion
821       * of sources
822       */
823 <    public void testThenCombine() {
824 <        CompletableFuture<Integer> f, g, h;
823 >    public void testThenCombine_normalCompletion1() {
824 >        for (ExecutionMode m : ExecutionMode.values())
825 >        for (Integer v1 : new Integer[] { 1, null })
826 >        for (Integer v2 : new Integer[] { 2, null }) {
827 >
828 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
829 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
830 >        final SubtractFunction r = new SubtractFunction();
831 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
832 >
833 >        f.complete(v1);
834 >        checkIncomplete(h);
835 >        assertFalse(r.ran());
836 >        g.complete(v2);
837 >
838 >        checkCompletedNormally(h, subtract(v1, v2));
839 >        checkCompletedNormally(f, v1);
840 >        checkCompletedNormally(g, v2);
841 >        }
842 >    }
843  
844 <        f = new CompletableFuture<>();
845 <        g = new CompletableFuture<>();
846 <        h = f.thenCombine(g, subtract);
847 <        f.complete(3);
848 <        checkIncomplete(h);
849 <        g.complete(1);
850 <        checkCompletedNormally(h, 2);
844 >    public void testThenCombine_normalCompletion2() {
845 >        for (ExecutionMode m : ExecutionMode.values())
846 >        for (Integer v1 : new Integer[] { 1, null })
847 >        for (Integer v2 : new Integer[] { 2, null }) {
848 >
849 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
850 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
851 >        final SubtractFunction r = new SubtractFunction();
852 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
853 >
854 >        g.complete(v2);
855 >        checkIncomplete(h);
856 >        assertFalse(r.ran());
857 >        f.complete(v1);
858 >
859 >        checkCompletedNormally(h, subtract(v1, v2));
860 >        checkCompletedNormally(f, v1);
861 >        checkCompletedNormally(g, v2);
862 >        }
863 >    }
864  
865 <        f = new CompletableFuture<>();
866 <        g = new CompletableFuture<>();
867 <        h = f.thenCombine(g, subtract);
868 <        g.complete(1);
869 <        checkIncomplete(h);
870 <        f.complete(3);
871 <        checkCompletedNormally(h, 2);
865 >    public void testThenCombine_normalCompletion3() {
866 >        for (ExecutionMode m : ExecutionMode.values())
867 >        for (Integer v1 : new Integer[] { 1, null })
868 >        for (Integer v2 : new Integer[] { 2, null }) {
869 >
870 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
871 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
872 >        final SubtractFunction r = new SubtractFunction();
873 >
874 >        g.complete(v2);
875 >        f.complete(v1);
876 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
877 >
878 >        checkCompletedNormally(h, subtract(v1, v2));
879 >        checkCompletedNormally(f, v1);
880 >        checkCompletedNormally(g, v2);
881 >        }
882 >    }
883  
884 <        f = new CompletableFuture<>();
885 <        g = new CompletableFuture<>();
886 <        g.complete(1);
887 <        f.complete(3);
888 <        h = f.thenCombine(g, subtract);
889 <        checkCompletedNormally(h, 2);
884 >    public void testThenCombine_normalCompletion4() {
885 >        for (ExecutionMode m : ExecutionMode.values())
886 >        for (Integer v1 : new Integer[] { 1, null })
887 >        for (Integer v2 : new Integer[] { 2, null }) {
888 >
889 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
890 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
891 >        final SubtractFunction r = new SubtractFunction();
892 >
893 >        f.complete(v1);
894 >        g.complete(v2);
895 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
896 >
897 >        checkCompletedNormally(h, subtract(v1, v2));
898 >        checkCompletedNormally(f, v1);
899 >        checkCompletedNormally(g, v2);
900 >        }
901      }
902  
903      /**
904       * thenCombine result completes exceptionally after exceptional
905       * completion of either source
906       */
907 <    public void testThenCombine2() {
908 <        CompletableFuture<Integer> f, g, h;
909 <
910 <        f = new CompletableFuture<>();
911 <        g = new CompletableFuture<>();
912 <        h = f.thenCombine(g, subtract);
913 <        f.completeExceptionally(new CFException());
914 <        checkIncomplete(h);
915 <        g.complete(1);
916 <        checkCompletedWithWrappedCFException(h);
907 >    public void testThenCombine_exceptionalCompletion1() {
908 >        for (ExecutionMode m : ExecutionMode.values())
909 >        for (Integer v1 : new Integer[] { 1, null }) {
910 >
911 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
912 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
913 >        final SubtractFunction r = new SubtractFunction();
914 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
915 >        final CFException ex = new CFException();
916 >
917 >        f.completeExceptionally(ex);
918 >        checkIncomplete(h);
919 >        g.complete(v1);
920 >
921 >        checkCompletedWithWrappedCFException(h, ex);
922 >        checkCompletedWithWrappedCFException(f, ex);
923 >        assertFalse(r.ran());
924 >        checkCompletedNormally(g, v1);
925 >        }
926 >    }
927  
928 <        f = new CompletableFuture<>();
929 <        g = new CompletableFuture<>();
930 <        h = f.thenCombine(g, subtract);
931 <        g.completeExceptionally(new CFException());
932 <        checkIncomplete(h);
933 <        f.complete(3);
934 <        checkCompletedWithWrappedCFException(h);
928 >    public void testThenCombine_exceptionalCompletion2() {
929 >        for (ExecutionMode m : ExecutionMode.values())
930 >        for (Integer v1 : new Integer[] { 1, null }) {
931 >
932 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
933 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
934 >        final SubtractFunction r = new SubtractFunction();
935 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
936 >        final CFException ex = new CFException();
937 >
938 >        g.completeExceptionally(ex);
939 >        checkIncomplete(h);
940 >        f.complete(v1);
941 >
942 >        checkCompletedWithWrappedCFException(h, ex);
943 >        checkCompletedWithWrappedCFException(g, ex);
944 >        assertFalse(r.ran());
945 >        checkCompletedNormally(f, v1);
946 >        }
947 >    }
948  
949 <        f = new CompletableFuture<>();
950 <        g = new CompletableFuture<>();
951 <        f.complete(3);
952 <        g.completeExceptionally(new CFException());
953 <        h = f.thenCombine(g, subtract);
954 <        checkCompletedWithWrappedCFException(h);
949 >    public void testThenCombine_exceptionalCompletion3() {
950 >        for (ExecutionMode m : ExecutionMode.values())
951 >        for (Integer v1 : new Integer[] { 1, null }) {
952 >
953 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
954 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
955 >        final SubtractFunction r = new SubtractFunction();
956 >        final CFException ex = new CFException();
957 >
958 >        g.completeExceptionally(ex);
959 >        f.complete(v1);
960 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
961 >
962 >        checkCompletedWithWrappedCFException(h, ex);
963 >        checkCompletedWithWrappedCFException(g, ex);
964 >        assertFalse(r.ran());
965 >        checkCompletedNormally(f, v1);
966 >        }
967 >    }
968  
969 <        f = new CompletableFuture<>();
970 <        g = new CompletableFuture<>();
971 <        f.completeExceptionally(new CFException());
972 <        g.complete(3);
973 <        h = f.thenCombine(g, subtract);
974 <        checkCompletedWithWrappedCFException(h);
969 >    public void testThenCombine_exceptionalCompletion4() {
970 >        for (ExecutionMode m : ExecutionMode.values())
971 >        for (Integer v1 : new Integer[] { 1, null }) {
972 >
973 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
974 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
975 >        final SubtractFunction r = new SubtractFunction();
976 >        final CFException ex = new CFException();
977 >
978 >        f.completeExceptionally(ex);
979 >        g.complete(v1);
980 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
981 >
982 >        checkCompletedWithWrappedCFException(h, ex);
983 >        checkCompletedWithWrappedCFException(f, ex);
984 >        assertFalse(r.ran());
985 >        checkCompletedNormally(g, v1);
986 >        }
987      }
988  
989      /**
990       * thenCombine result completes exceptionally if action does
991       */
992 <    public void testThenCombine3() {
993 <        CompletableFuture<Integer> f = new CompletableFuture<>();
994 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
995 <        FailingBiFunction r = new FailingBiFunction();
996 <        CompletableFuture<Integer> g = f.thenCombine(f2, r);
997 <        f.complete(one);
998 <        checkIncomplete(g);
999 <        assertFalse(r.ran);
1000 <        f2.complete(two);
1001 <        checkCompletedWithWrappedCFException(g);
1002 <        assertTrue(r.ran);
992 >    public void testThenCombine_actionFailed1() {
993 >        for (ExecutionMode m : ExecutionMode.values())
994 >        for (Integer v1 : new Integer[] { 1, null })
995 >        for (Integer v2 : new Integer[] { 2, null }) {
996 >
997 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
998 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
999 >        final FailingBiFunction r = new FailingBiFunction();
1000 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1001 >
1002 >        f.complete(v1);
1003 >        checkIncomplete(h);
1004 >        g.complete(v2);
1005 >
1006 >        checkCompletedWithWrappedCFException(h);
1007 >        checkCompletedNormally(f, v1);
1008 >        checkCompletedNormally(g, v2);
1009 >        }
1010 >    }
1011 >
1012 >    public void testThenCombine_actionFailed2() {
1013 >        for (ExecutionMode m : ExecutionMode.values())
1014 >        for (Integer v1 : new Integer[] { 1, null })
1015 >        for (Integer v2 : new Integer[] { 2, null }) {
1016 >
1017 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1018 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1019 >        final FailingBiFunction r = new FailingBiFunction();
1020 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1021 >
1022 >        g.complete(v2);
1023 >        checkIncomplete(h);
1024 >        f.complete(v1);
1025 >
1026 >        checkCompletedWithWrappedCFException(h);
1027 >        checkCompletedNormally(f, v1);
1028 >        checkCompletedNormally(g, v2);
1029 >        }
1030      }
1031  
1032      /**
1033       * thenCombine result completes exceptionally if either source cancelled
1034       */
1035 <    public void testThenCombine4() {
1036 <        CompletableFuture<Integer> f, g, h;
1035 >    public void testThenCombine_sourceCancelled1() {
1036 >        for (ExecutionMode m : ExecutionMode.values())
1037 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1038 >        for (Integer v1 : new Integer[] { 1, null }) {
1039 >
1040 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1041 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1042 >        final SubtractFunction r = new SubtractFunction();
1043 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1044  
1045 <        f = new CompletableFuture<>();
726 <        g = new CompletableFuture<>();
727 <        h = f.thenCombine(g, subtract);
728 <        assertTrue(f.cancel(true));
1045 >        assertTrue(f.cancel(mayInterruptIfRunning));
1046          checkIncomplete(h);
1047 <        g.complete(1);
1047 >        g.complete(v1);
1048 >
1049          checkCompletedWithWrappedCancellationException(h);
1050 +        checkCancelled(f);
1051 +        assertFalse(r.ran());
1052 +        checkCompletedNormally(g, v1);
1053 +        }
1054 +    }
1055  
1056 <        f = new CompletableFuture<>();
1057 <        g = new CompletableFuture<>();
1058 <        h = f.thenCombine(g, subtract);
1059 <        assertTrue(g.cancel(true));
1056 >    public void testThenCombine_sourceCancelled2() {
1057 >        for (ExecutionMode m : ExecutionMode.values())
1058 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1059 >        for (Integer v1 : new Integer[] { 1, null }) {
1060 >
1061 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1062 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1063 >        final SubtractFunction r = new SubtractFunction();
1064 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1065 >
1066 >        assertTrue(g.cancel(mayInterruptIfRunning));
1067          checkIncomplete(h);
1068 <        f.complete(3);
1068 >        f.complete(v1);
1069 >
1070          checkCompletedWithWrappedCancellationException(h);
1071 +        checkCancelled(g);
1072 +        assertFalse(r.ran());
1073 +        checkCompletedNormally(f, v1);
1074 +        }
1075 +    }
1076 +
1077 +    public void testThenCombine_sourceCancelled3() {
1078 +        for (ExecutionMode m : ExecutionMode.values())
1079 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1080 +        for (Integer v1 : new Integer[] { 1, null }) {
1081 +
1082 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1083 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1084 +        final SubtractFunction r = new SubtractFunction();
1085 +
1086 +        assertTrue(g.cancel(mayInterruptIfRunning));
1087 +        f.complete(v1);
1088 +        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1089 +
1090 +        checkCompletedWithWrappedCancellationException(h);
1091 +        checkCancelled(g);
1092 +        assertFalse(r.ran());
1093 +        checkCompletedNormally(f, v1);
1094 +        }
1095 +    }
1096 +
1097 +    public void testThenCombine_sourceCancelled4() {
1098 +        for (ExecutionMode m : ExecutionMode.values())
1099 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1100 +        for (Integer v1 : new Integer[] { 1, null }) {
1101 +
1102 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1103 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1104 +        final SubtractFunction r = new SubtractFunction();
1105 +
1106 +        assertTrue(f.cancel(mayInterruptIfRunning));
1107 +        g.complete(v1);
1108 +        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1109  
741        f = new CompletableFuture<>();
742        g = new CompletableFuture<>();
743        assertTrue(f.cancel(true));
744        assertTrue(g.cancel(true));
745        h = f.thenCombine(g, subtract);
1110          checkCompletedWithWrappedCancellationException(h);
1111 +        checkCancelled(f);
1112 +        assertFalse(r.ran());
1113 +        checkCompletedNormally(g, v1);
1114 +        }
1115      }
1116  
1117      /**
1118       * thenAcceptBoth result completes normally after normal
1119       * completion of sources
1120       */
1121 <    public void testThenAcceptBoth() {
1122 <        CompletableFuture<Integer> f, g;
1123 <        CompletableFuture<Void> h;
1124 <        SubtractAction r;
1121 >    public void testThenAcceptBoth_normalCompletion1() {
1122 >        for (ExecutionMode m : ExecutionMode.values())
1123 >        for (Integer v1 : new Integer[] { 1, null })
1124 >        for (Integer v2 : new Integer[] { 2, null }) {
1125 >
1126 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1127 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1128 >        final SubtractAction r = new SubtractAction();
1129 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1130  
1131 <        f = new CompletableFuture<>();
759 <        g = new CompletableFuture<>();
760 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
761 <        f.complete(3);
1131 >        f.complete(v1);
1132          checkIncomplete(h);
1133 <        g.complete(1);
1133 >        assertFalse(r.ran());
1134 >        g.complete(v2);
1135 >
1136          checkCompletedNormally(h, null);
1137 <        assertEquals(r.value, 2);
1137 >        assertEquals(r.value, subtract(v1, v2));
1138 >        checkCompletedNormally(f, v1);
1139 >        checkCompletedNormally(g, v2);
1140 >        }
1141 >    }
1142  
1143 <        f = new CompletableFuture<>();
1144 <        g = new CompletableFuture<>();
1145 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
1146 <        g.complete(1);
1143 >    public void testThenAcceptBoth_normalCompletion2() {
1144 >        for (ExecutionMode m : ExecutionMode.values())
1145 >        for (Integer v1 : new Integer[] { 1, null })
1146 >        for (Integer v2 : new Integer[] { 2, null }) {
1147 >
1148 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1149 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1150 >        final SubtractAction r = new SubtractAction();
1151 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1152 >
1153 >        g.complete(v2);
1154          checkIncomplete(h);
1155 <        f.complete(3);
1155 >        assertFalse(r.ran());
1156 >        f.complete(v1);
1157 >
1158          checkCompletedNormally(h, null);
1159 <        assertEquals(r.value, 2);
1159 >        assertEquals(r.value, subtract(v1, v2));
1160 >        checkCompletedNormally(f, v1);
1161 >        checkCompletedNormally(g, v2);
1162 >        }
1163 >    }
1164 >
1165 >    public void testThenAcceptBoth_normalCompletion3() {
1166 >        for (ExecutionMode m : ExecutionMode.values())
1167 >        for (Integer v1 : new Integer[] { 1, null })
1168 >        for (Integer v2 : new Integer[] { 2, null }) {
1169 >
1170 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1171 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1172 >        final SubtractAction r = new SubtractAction();
1173 >
1174 >        g.complete(v2);
1175 >        f.complete(v1);
1176 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1177  
776        f = new CompletableFuture<>();
777        g = new CompletableFuture<>();
778        g.complete(1);
779        f.complete(3);
780        h = f.thenAcceptBoth(g, r = new SubtractAction());
1178          checkCompletedNormally(h, null);
1179 <        assertEquals(r.value, 2);
1179 >        assertEquals(r.value, subtract(v1, v2));
1180 >        checkCompletedNormally(f, v1);
1181 >        checkCompletedNormally(g, v2);
1182 >        }
1183 >    }
1184 >
1185 >    public void testThenAcceptBoth_normalCompletion4() {
1186 >        for (ExecutionMode m : ExecutionMode.values())
1187 >        for (Integer v1 : new Integer[] { 1, null })
1188 >        for (Integer v2 : new Integer[] { 2, null }) {
1189 >
1190 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1191 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1192 >        final SubtractAction r = new SubtractAction();
1193 >
1194 >        f.complete(v1);
1195 >        g.complete(v2);
1196 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1197 >
1198 >        checkCompletedNormally(h, null);
1199 >        assertEquals(r.value, subtract(v1, v2));
1200 >        checkCompletedNormally(f, v1);
1201 >        checkCompletedNormally(g, v2);
1202 >        }
1203      }
1204  
1205      /**
1206       * thenAcceptBoth result completes exceptionally after exceptional
1207       * completion of either source
1208       */
1209 <    public void testThenAcceptBoth2() {
1210 <        CompletableFuture<Integer> f, g;
1211 <        CompletableFuture<Void> h;
1212 <        SubtractAction r;
1213 <
1214 <        f = new CompletableFuture<>();
1215 <        g = new CompletableFuture<>();
1216 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
1217 <        f.completeExceptionally(new CFException());
1218 <        checkIncomplete(h);
1219 <        g.complete(1);
1220 <        checkCompletedWithWrappedCFException(h);
1209 >    public void testThenAcceptBoth_exceptionalCompletion1() {
1210 >        for (ExecutionMode m : ExecutionMode.values())
1211 >        for (Integer v1 : new Integer[] { 1, null }) {
1212 >
1213 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1214 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1215 >        final SubtractAction r = new SubtractAction();
1216 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1217 >        final CFException ex = new CFException();
1218 >
1219 >        f.completeExceptionally(ex);
1220 >        checkIncomplete(h);
1221 >        g.complete(v1);
1222 >
1223 >        checkCompletedWithWrappedCFException(h, ex);
1224 >        checkCompletedWithWrappedCFException(f, ex);
1225 >        assertFalse(r.ran());
1226 >        checkCompletedNormally(g, v1);
1227 >        }
1228 >    }
1229  
1230 <        f = new CompletableFuture<>();
1231 <        g = new CompletableFuture<>();
1232 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
1233 <        g.completeExceptionally(new CFException());
1234 <        checkIncomplete(h);
1235 <        f.complete(3);
1236 <        checkCompletedWithWrappedCFException(h);
1230 >    public void testThenAcceptBoth_exceptionalCompletion2() {
1231 >        for (ExecutionMode m : ExecutionMode.values())
1232 >        for (Integer v1 : new Integer[] { 1, null }) {
1233 >
1234 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1235 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1236 >        final SubtractAction r = new SubtractAction();
1237 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1238 >        final CFException ex = new CFException();
1239 >
1240 >        g.completeExceptionally(ex);
1241 >        checkIncomplete(h);
1242 >        f.complete(v1);
1243 >
1244 >        checkCompletedWithWrappedCFException(h, ex);
1245 >        checkCompletedWithWrappedCFException(g, ex);
1246 >        assertFalse(r.ran());
1247 >        checkCompletedNormally(f, v1);
1248 >        }
1249 >    }
1250  
1251 <        f = new CompletableFuture<>();
1252 <        g = new CompletableFuture<>();
1253 <        f.complete(3);
1254 <        g.completeExceptionally(new CFException());
1255 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
1256 <        checkCompletedWithWrappedCFException(h);
1251 >    public void testThenAcceptBoth_exceptionalCompletion3() {
1252 >        for (ExecutionMode m : ExecutionMode.values())
1253 >        for (Integer v1 : new Integer[] { 1, null }) {
1254 >
1255 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1256 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1257 >        final SubtractAction r = new SubtractAction();
1258 >        final CFException ex = new CFException();
1259 >
1260 >        g.completeExceptionally(ex);
1261 >        f.complete(v1);
1262 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1263 >
1264 >        checkCompletedWithWrappedCFException(h, ex);
1265 >        checkCompletedWithWrappedCFException(g, ex);
1266 >        assertFalse(r.ran());
1267 >        checkCompletedNormally(f, v1);
1268 >        }
1269 >    }
1270  
1271 <        f = new CompletableFuture<>();
1272 <        g = new CompletableFuture<>();
1273 <        f.completeExceptionally(new CFException());
1274 <        g.complete(3);
1275 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
1276 <        checkCompletedWithWrappedCFException(h);
1271 >    public void testThenAcceptBoth_exceptionalCompletion4() {
1272 >        for (ExecutionMode m : ExecutionMode.values())
1273 >        for (Integer v1 : new Integer[] { 1, null }) {
1274 >
1275 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1276 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1277 >        final SubtractAction r = new SubtractAction();
1278 >        final CFException ex = new CFException();
1279 >
1280 >        f.completeExceptionally(ex);
1281 >        g.complete(v1);
1282 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1283 >
1284 >        checkCompletedWithWrappedCFException(h, ex);
1285 >        checkCompletedWithWrappedCFException(f, ex);
1286 >        assertFalse(r.ran());
1287 >        checkCompletedNormally(g, v1);
1288 >        }
1289      }
1290  
1291      /**
1292       * thenAcceptBoth result completes exceptionally if action does
1293       */
1294 <    public void testThenAcceptBoth3() {
1295 <        CompletableFuture<Integer> f, g;
1296 <        CompletableFuture<Void> h;
1297 <        FailingBiConsumer r;
1294 >    public void testThenAcceptBoth_actionFailed1() {
1295 >        for (ExecutionMode m : ExecutionMode.values())
1296 >        for (Integer v1 : new Integer[] { 1, null })
1297 >        for (Integer v2 : new Integer[] { 2, null }) {
1298  
1299 <        f = new CompletableFuture<>();
1300 <        g = new CompletableFuture<>();
1301 <        h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
1302 <        f.complete(3);
1299 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1300 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1301 >        final FailingBiConsumer r = new FailingBiConsumer();
1302 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1303 >
1304 >        f.complete(v1);
1305          checkIncomplete(h);
1306 <        g.complete(1);
1306 >        g.complete(v2);
1307 >
1308          checkCompletedWithWrappedCFException(h);
1309 +        checkCompletedNormally(f, v1);
1310 +        checkCompletedNormally(g, v2);
1311 +        }
1312 +    }
1313 +
1314 +    public void testThenAcceptBoth_actionFailed2() {
1315 +        for (ExecutionMode m : ExecutionMode.values())
1316 +        for (Integer v1 : new Integer[] { 1, null })
1317 +        for (Integer v2 : new Integer[] { 2, null }) {
1318 +
1319 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1320 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1321 +        final FailingBiConsumer r = new FailingBiConsumer();
1322 +        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1323 +
1324 +        g.complete(v2);
1325 +        checkIncomplete(h);
1326 +        f.complete(v1);
1327  
841        f = new CompletableFuture<>();
842        g = new CompletableFuture<>();
843        f.complete(3);
844        g.complete(1);
845        h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
1328          checkCompletedWithWrappedCFException(h);
1329 +        checkCompletedNormally(f, v1);
1330 +        checkCompletedNormally(g, v2);
1331 +        }
1332      }
1333  
1334      /**
1335       * thenAcceptBoth result completes exceptionally if either source cancelled
1336       */
1337 <    public void testThenAcceptBoth4() {
1338 <        CompletableFuture<Integer> f, g;
1339 <        CompletableFuture<Void> h;
1340 <        SubtractAction r;
1337 >    public void testThenAcceptBoth_sourceCancelled1() {
1338 >        for (ExecutionMode m : ExecutionMode.values())
1339 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
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 SubtractAction r = new SubtractAction();
1345 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1346  
1347 <        f = new CompletableFuture<>();
858 <        g = new CompletableFuture<>();
859 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
860 <        assertTrue(f.cancel(true));
1347 >        assertTrue(f.cancel(mayInterruptIfRunning));
1348          checkIncomplete(h);
1349 <        g.complete(1);
1349 >        g.complete(v1);
1350 >
1351          checkCompletedWithWrappedCancellationException(h);
1352 +        checkCancelled(f);
1353 +        assertFalse(r.ran());
1354 +        checkCompletedNormally(g, v1);
1355 +        }
1356 +    }
1357  
1358 <        f = new CompletableFuture<>();
1359 <        g = new CompletableFuture<>();
1360 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
1361 <        assertTrue(g.cancel(true));
1358 >    public void testThenAcceptBoth_sourceCancelled2() {
1359 >        for (ExecutionMode m : ExecutionMode.values())
1360 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1361 >        for (Integer v1 : new Integer[] { 1, null }) {
1362 >
1363 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1364 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1365 >        final SubtractAction r = new SubtractAction();
1366 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1367 >
1368 >        assertTrue(g.cancel(mayInterruptIfRunning));
1369          checkIncomplete(h);
1370 <        f.complete(3);
871 <        checkCompletedWithWrappedCancellationException(h);
1370 >        f.complete(v1);
1371  
873        f = new CompletableFuture<>();
874        g = new CompletableFuture<>();
875        f.complete(3);
876        assertTrue(g.cancel(true));
877        h = f.thenAcceptBoth(g, r = new SubtractAction());
1372          checkCompletedWithWrappedCancellationException(h);
1373 +        checkCancelled(g);
1374 +        assertFalse(r.ran());
1375 +        checkCompletedNormally(f, v1);
1376 +        }
1377 +    }
1378 +
1379 +    public void testThenAcceptBoth_sourceCancelled3() {
1380 +        for (ExecutionMode m : ExecutionMode.values())
1381 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1382 +        for (Integer v1 : new Integer[] { 1, null }) {
1383 +
1384 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1385 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1386 +        final SubtractAction r = new SubtractAction();
1387 +
1388 +        assertTrue(g.cancel(mayInterruptIfRunning));
1389 +        f.complete(v1);
1390 +        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1391 +
1392 +        checkCompletedWithWrappedCancellationException(h);
1393 +        checkCancelled(g);
1394 +        assertFalse(r.ran());
1395 +        checkCompletedNormally(f, v1);
1396 +        }
1397 +    }
1398 +
1399 +    public void testThenAcceptBoth_sourceCancelled4() {
1400 +        for (ExecutionMode m : ExecutionMode.values())
1401 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1402 +        for (Integer v1 : new Integer[] { 1, null }) {
1403 +
1404 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1405 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1406 +        final SubtractAction r = new SubtractAction();
1407 +
1408 +        assertTrue(f.cancel(mayInterruptIfRunning));
1409 +        g.complete(v1);
1410 +        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1411  
880        f = new CompletableFuture<>();
881        g = new CompletableFuture<>();
882        assertTrue(f.cancel(true));
883        g.complete(3);
884        h = f.thenAcceptBoth(g, r = new SubtractAction());
1412          checkCompletedWithWrappedCancellationException(h);
1413 +        checkCancelled(f);
1414 +        assertFalse(r.ran());
1415 +        checkCompletedNormally(g, v1);
1416 +        }
1417      }
1418  
1419      /**
1420       * runAfterBoth result completes normally after normal
1421       * completion of sources
1422       */
1423 <    public void testRunAfterBoth() {
1424 <        CompletableFuture<Integer> f, g;
1425 <        CompletableFuture<Void> h;
1426 <        Noop r;
1423 >    public void testRunAfterBoth_normalCompletion1() {
1424 >        for (ExecutionMode m : ExecutionMode.values())
1425 >        for (Integer v1 : new Integer[] { 1, null })
1426 >        for (Integer v2 : new Integer[] { 2, null }) {
1427 >
1428 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1429 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1430 >        final Noop r = new Noop();
1431 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1432  
1433 <        f = new CompletableFuture<>();
898 <        g = new CompletableFuture<>();
899 <        h = f.runAfterBoth(g, r = new Noop());
900 <        f.complete(3);
1433 >        f.complete(v1);
1434          checkIncomplete(h);
1435 <        g.complete(1);
1435 >        assertFalse(r.ran);
1436 >        g.complete(v2);
1437 >
1438          checkCompletedNormally(h, null);
1439          assertTrue(r.ran);
1440 +        checkCompletedNormally(f, v1);
1441 +        checkCompletedNormally(g, v2);
1442 +        }
1443 +    }
1444  
1445 <        f = new CompletableFuture<>();
1446 <        g = new CompletableFuture<>();
1447 <        h = f.runAfterBoth(g, r = new Noop());
1448 <        g.complete(1);
1445 >    public void testRunAfterBoth_normalCompletion2() {
1446 >        for (ExecutionMode m : ExecutionMode.values())
1447 >        for (Integer v1 : new Integer[] { 1, null })
1448 >        for (Integer v2 : new Integer[] { 2, null }) {
1449 >
1450 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1451 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1452 >        final Noop r = new Noop();
1453 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1454 >
1455 >        g.complete(v2);
1456          checkIncomplete(h);
1457 <        f.complete(3);
1457 >        assertFalse(r.ran);
1458 >        f.complete(v1);
1459 >
1460          checkCompletedNormally(h, null);
1461          assertTrue(r.ran);
1462 +        checkCompletedNormally(f, v1);
1463 +        checkCompletedNormally(g, v2);
1464 +        }
1465 +    }
1466 +
1467 +    public void testRunAfterBoth_normalCompletion3() {
1468 +        for (ExecutionMode m : ExecutionMode.values())
1469 +        for (Integer v1 : new Integer[] { 1, null })
1470 +        for (Integer v2 : new Integer[] { 2, null }) {
1471 +
1472 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1473 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1474 +        final Noop r = new Noop();
1475 +
1476 +        g.complete(v2);
1477 +        f.complete(v1);
1478 +        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1479  
915        f = new CompletableFuture<>();
916        g = new CompletableFuture<>();
917        g.complete(1);
918        f.complete(3);
919        h = f.runAfterBoth(g, r = new Noop());
1480          checkCompletedNormally(h, null);
1481          assertTrue(r.ran);
1482 +        checkCompletedNormally(f, v1);
1483 +        checkCompletedNormally(g, v2);
1484 +        }
1485 +    }
1486 +
1487 +    public void testRunAfterBoth_normalCompletion4() {
1488 +        for (ExecutionMode m : ExecutionMode.values())
1489 +        for (Integer v1 : new Integer[] { 1, null })
1490 +        for (Integer v2 : new Integer[] { 2, null }) {
1491 +
1492 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1493 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1494 +        final Noop r = new Noop();
1495 +
1496 +        f.complete(v1);
1497 +        g.complete(v2);
1498 +        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1499 +
1500 +        checkCompletedNormally(h, null);
1501 +        assertTrue(r.ran);
1502 +        checkCompletedNormally(f, v1);
1503 +        checkCompletedNormally(g, v2);
1504 +        }
1505      }
1506  
1507      /**
1508       * runAfterBoth result completes exceptionally after exceptional
1509       * completion of either source
1510       */
1511 <    public void testRunAfterBoth2() {
1512 <        CompletableFuture<Integer> f, g;
1513 <        CompletableFuture<Void> h;
1514 <        Noop r;
1511 >    public void testRunAfterBoth_exceptionalCompletion1() {
1512 >        for (ExecutionMode m : ExecutionMode.values())
1513 >        for (Integer v1 : new Integer[] { 1, null }) {
1514 >
1515 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1516 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1517 >        final Noop r = new Noop();
1518 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1519 >        final CFException ex = new CFException();
1520  
1521 <        f = new CompletableFuture<>();
934 <        g = new CompletableFuture<>();
935 <        h = f.runAfterBoth(g, r = new Noop());
936 <        f.completeExceptionally(new CFException());
1521 >        f.completeExceptionally(ex);
1522          checkIncomplete(h);
1523 <        g.complete(1);
1524 <        checkCompletedWithWrappedCFException(h);
1523 >        g.complete(v1);
1524 >
1525 >        checkCompletedWithWrappedCFException(h, ex);
1526 >        checkCompletedWithWrappedCFException(f, ex);
1527          assertFalse(r.ran);
1528 +        checkCompletedNormally(g, v1);
1529 +        }
1530 +    }
1531  
1532 <        f = new CompletableFuture<>();
1533 <        g = new CompletableFuture<>();
1534 <        h = f.runAfterBoth(g, r = new Noop());
1535 <        g.completeExceptionally(new CFException());
1532 >    public void testRunAfterBoth_exceptionalCompletion2() {
1533 >        for (ExecutionMode m : ExecutionMode.values())
1534 >        for (Integer v1 : new Integer[] { 1, null }) {
1535 >
1536 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1537 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1538 >        final Noop r = new Noop();
1539 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1540 >        final CFException ex = new CFException();
1541 >
1542 >        g.completeExceptionally(ex);
1543          checkIncomplete(h);
1544 <        f.complete(3);
1545 <        checkCompletedWithWrappedCFException(h);
1544 >        f.complete(v1);
1545 >
1546 >        checkCompletedWithWrappedCFException(h, ex);
1547 >        checkCompletedWithWrappedCFException(g, ex);
1548          assertFalse(r.ran);
1549 +        checkCompletedNormally(f, v1);
1550 +        }
1551 +    }
1552  
1553 <        f = new CompletableFuture<>();
1554 <        g = new CompletableFuture<>();
1555 <        g.completeExceptionally(new CFException());
1556 <        f.complete(3);
1557 <        h = f.runAfterBoth(g, r = new Noop());
1558 <        checkCompletedWithWrappedCFException(h);
1553 >    public void testRunAfterBoth_exceptionalCompletion3() {
1554 >        for (ExecutionMode m : ExecutionMode.values())
1555 >        for (Integer v1 : new Integer[] { 1, null }) {
1556 >
1557 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1558 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1559 >        final Noop r = new Noop();
1560 >        final CFException ex = new CFException();
1561 >
1562 >        g.completeExceptionally(ex);
1563 >        f.complete(v1);
1564 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1565 >
1566 >        checkCompletedWithWrappedCFException(h, ex);
1567 >        checkCompletedWithWrappedCFException(g, ex);
1568          assertFalse(r.ran);
1569 +        checkCompletedNormally(f, v1);
1570 +        }
1571 +    }
1572  
1573 <        f = new CompletableFuture<>();
1574 <        g = new CompletableFuture<>();
1575 <        f.completeExceptionally(new CFException());
1576 <        g.complete(1);
1577 <        h = f.runAfterBoth(g, r = new Noop());
1578 <        checkCompletedWithWrappedCFException(h);
1573 >    public void testRunAfterBoth_exceptionalCompletion4() {
1574 >        for (ExecutionMode m : ExecutionMode.values())
1575 >        for (Integer v1 : new Integer[] { 1, null }) {
1576 >
1577 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1578 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1579 >        final Noop r = new Noop();
1580 >        final CFException ex = new CFException();
1581 >
1582 >        f.completeExceptionally(ex);
1583 >        g.complete(v1);
1584 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1585 >
1586 >        checkCompletedWithWrappedCFException(h, ex);
1587 >        checkCompletedWithWrappedCFException(f, ex);
1588          assertFalse(r.ran);
1589 +        checkCompletedNormally(g, v1);
1590 +        }
1591      }
1592  
1593      /**
1594       * runAfterBoth result completes exceptionally if action does
1595       */
1596 <    public void testRunAfterBoth3() {
1597 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1598 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1599 <        FailingNoop r = new FailingNoop();
1600 <        CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1601 <        f.complete(one);
1602 <        checkIncomplete(g);
1603 <        f2.complete(two);
1604 <        checkCompletedWithWrappedCFException(g);
1596 >    public void testRunAfterBoth_actionFailed1() {
1597 >        for (ExecutionMode m : ExecutionMode.values())
1598 >        for (Integer v1 : new Integer[] { 1, null })
1599 >        for (Integer v2 : new Integer[] { 2, null }) {
1600 >
1601 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1602 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1603 >        final FailingNoop r = new FailingNoop();
1604 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1605 >
1606 >        f.complete(v1);
1607 >        checkIncomplete(h);
1608 >        g.complete(v2);
1609 >
1610 >        checkCompletedWithWrappedCFException(h);
1611 >        checkCompletedNormally(f, v1);
1612 >        checkCompletedNormally(g, v2);
1613 >        }
1614 >    }
1615 >
1616 >    public void testRunAfterBoth_actionFailed2() {
1617 >        for (ExecutionMode m : ExecutionMode.values())
1618 >        for (Integer v1 : new Integer[] { 1, null })
1619 >        for (Integer v2 : new Integer[] { 2, null }) {
1620 >
1621 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1622 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1623 >        final FailingNoop r = new FailingNoop();
1624 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1625 >
1626 >        g.complete(v2);
1627 >        checkIncomplete(h);
1628 >        f.complete(v1);
1629 >
1630 >        checkCompletedWithWrappedCFException(h);
1631 >        checkCompletedNormally(f, v1);
1632 >        checkCompletedNormally(g, v2);
1633 >        }
1634      }
1635  
1636      /**
1637       * runAfterBoth result completes exceptionally if either source cancelled
1638       */
1639 <    public void testRunAfterBoth4() {
1640 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1641 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1642 <        Noop r = new Noop();
1643 <        CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1644 <        assertTrue(f.cancel(true));
1645 <        f2.complete(two);
1646 <        checkCompletedWithWrappedCancellationException(g);
1647 <        f = new CompletableFuture<>();
1648 <        f2 = new CompletableFuture<>();
1649 <        r = new Noop();
1650 <        g = f.runAfterBoth(f2, r);
1651 <        f.complete(one);
1652 <        assertTrue(f2.cancel(true));
1653 <        checkCompletedWithWrappedCancellationException(g);
1639 >    public void testRunAfterBoth_sourceCancelled1() {
1640 >        for (ExecutionMode m : ExecutionMode.values())
1641 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1642 >        for (Integer v1 : new Integer[] { 1, null }) {
1643 >
1644 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1645 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1646 >        final Noop r = new Noop();
1647 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1648 >
1649 >        assertTrue(f.cancel(mayInterruptIfRunning));
1650 >        checkIncomplete(h);
1651 >        g.complete(v1);
1652 >
1653 >        checkCompletedWithWrappedCancellationException(h);
1654 >        checkCancelled(f);
1655 >        assertFalse(r.ran);
1656 >        checkCompletedNormally(g, v1);
1657 >        }
1658 >    }
1659 >
1660 >    public void testRunAfterBoth_sourceCancelled2() {
1661 >        for (ExecutionMode m : ExecutionMode.values())
1662 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1663 >        for (Integer v1 : new Integer[] { 1, null }) {
1664 >
1665 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1666 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1667 >        final Noop r = new Noop();
1668 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1669 >
1670 >        assertTrue(g.cancel(mayInterruptIfRunning));
1671 >        checkIncomplete(h);
1672 >        f.complete(v1);
1673 >
1674 >        checkCompletedWithWrappedCancellationException(h);
1675 >        checkCancelled(g);
1676 >        assertFalse(r.ran);
1677 >        checkCompletedNormally(f, v1);
1678 >        }
1679 >    }
1680 >
1681 >    public void testRunAfterBoth_sourceCancelled3() {
1682 >        for (ExecutionMode m : ExecutionMode.values())
1683 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1684 >        for (Integer v1 : new Integer[] { 1, null }) {
1685 >
1686 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1687 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1688 >        final Noop r = new Noop();
1689 >
1690 >        assertTrue(g.cancel(mayInterruptIfRunning));
1691 >        f.complete(v1);
1692 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1693 >
1694 >        checkCompletedWithWrappedCancellationException(h);
1695 >        checkCancelled(g);
1696 >        assertFalse(r.ran);
1697 >        checkCompletedNormally(f, v1);
1698 >        }
1699 >    }
1700 >
1701 >    public void testRunAfterBoth_sourceCancelled4() {
1702 >        for (ExecutionMode m : ExecutionMode.values())
1703 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1704 >        for (Integer v1 : new Integer[] { 1, null }) {
1705 >
1706 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1707 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1708 >        final Noop r = new Noop();
1709 >
1710 >        assertTrue(f.cancel(mayInterruptIfRunning));
1711 >        g.complete(v1);
1712 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1713 >
1714 >        checkCompletedWithWrappedCancellationException(h);
1715 >        checkCancelled(f);
1716 >        assertFalse(r.ran);
1717 >        checkCompletedNormally(g, v1);
1718 >        }
1719      }
1720  
1721      /**
# Line 1138 | Line 1857 | public class CompletableFutureTest exten
1857          checkCompletedWithWrappedCancellationException(g);
1858      }
1859  
1141
1860      /**
1861       * runAfterEither result completes normally after normal completion
1862       * of either source
# Line 1287 | Line 2005 | public class CompletableFutureTest exten
2005          checkCompletedWithWrappedCancellationException(g);
2006      }
2007  
1290
2008      // asyncs
2009  
2010      /**
# Line 1320 | Line 2037 | public class CompletableFutureTest exten
2037          try {
2038              g.join();
2039              shouldThrow();
2040 <        } catch (Exception ok) {
1324 <        }
2040 >        } catch (CompletionException success) {}
2041          checkCompletedWithWrappedCFException(g);
2042      }
2043  
# Line 1437 | Line 2153 | public class CompletableFutureTest exten
2153      }
2154  
2155      /**
1440     * thenCombineAsync result completes normally after normal
1441     * completion of sources
1442     */
1443    public void testThenCombineAsync() {
1444        CompletableFuture<Integer> f, g, h;
1445
1446        f = new CompletableFuture<>();
1447        g = new CompletableFuture<>();
1448        h = f.thenCombineAsync(g, subtract);
1449        f.complete(3);
1450        checkIncomplete(h);
1451        g.complete(1);
1452        checkCompletedNormally(h, 2);
1453
1454        f = new CompletableFuture<>();
1455        g = new CompletableFuture<>();
1456        h = f.thenCombineAsync(g, subtract);
1457        g.complete(1);
1458        checkIncomplete(h);
1459        f.complete(3);
1460        checkCompletedNormally(h, 2);
1461
1462        f = new CompletableFuture<>();
1463        g = new CompletableFuture<>();
1464        g.complete(1);
1465        f.complete(3);
1466        h = f.thenCombineAsync(g, subtract);
1467        checkCompletedNormally(h, 2);
1468    }
1469
1470    /**
1471     * thenCombineAsync result completes exceptionally after exceptional
1472     * completion of either source
1473     */
1474    public void testThenCombineAsync2() {
1475        CompletableFuture<Integer> f, g, h;
1476
1477        f = new CompletableFuture<>();
1478        g = new CompletableFuture<>();
1479        h = f.thenCombineAsync(g, subtract);
1480        f.completeExceptionally(new CFException());
1481        checkIncomplete(h);
1482        g.complete(1);
1483        checkCompletedWithWrappedCFException(h);
1484
1485        f = new CompletableFuture<>();
1486        g = new CompletableFuture<>();
1487        h = f.thenCombineAsync(g, subtract);
1488        g.completeExceptionally(new CFException());
1489        checkIncomplete(h);
1490        f.complete(3);
1491        checkCompletedWithWrappedCFException(h);
1492
1493        f = new CompletableFuture<>();
1494        g = new CompletableFuture<>();
1495        g.completeExceptionally(new CFException());
1496        f.complete(3);
1497        h = f.thenCombineAsync(g, subtract);
1498        checkCompletedWithWrappedCFException(h);
1499    }
1500
1501    /**
1502     * thenCombineAsync result completes exceptionally if action does
1503     */
1504    public void testThenCombineAsync3() {
1505        CompletableFuture<Integer> f = new CompletableFuture<>();
1506        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1507        FailingBiFunction r = new FailingBiFunction();
1508        CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1509        f.complete(one);
1510        checkIncomplete(g);
1511        assertFalse(r.ran);
1512        f2.complete(two);
1513        checkCompletedWithWrappedCFException(g);
1514        assertTrue(r.ran);
1515    }
1516
1517    /**
1518     * thenCombineAsync result completes exceptionally if either source cancelled
1519     */
1520    public void testThenCombineAsync4() {
1521        CompletableFuture<Integer> f, g, h;
1522
1523        f = new CompletableFuture<>();
1524        g = new CompletableFuture<>();
1525        h = f.thenCombineAsync(g, subtract);
1526        assertTrue(f.cancel(true));
1527        checkIncomplete(h);
1528        g.complete(1);
1529        checkCompletedWithWrappedCancellationException(h);
1530
1531        f = new CompletableFuture<>();
1532        g = new CompletableFuture<>();
1533        h = f.thenCombineAsync(g, subtract);
1534        assertTrue(g.cancel(true));
1535        checkIncomplete(h);
1536        f.complete(3);
1537        checkCompletedWithWrappedCancellationException(h);
1538
1539        f = new CompletableFuture<>();
1540        g = new CompletableFuture<>();
1541        g.complete(3);
1542        assertTrue(f.cancel(true));
1543        h = f.thenCombineAsync(g, subtract);
1544        checkCompletedWithWrappedCancellationException(h);
1545
1546        f = new CompletableFuture<>();
1547        g = new CompletableFuture<>();
1548        f.complete(3);
1549        assertTrue(g.cancel(true));
1550        h = f.thenCombineAsync(g, subtract);
1551        checkCompletedWithWrappedCancellationException(h);
1552    }
1553
1554    /**
1555     * thenAcceptBothAsync result completes normally after normal
1556     * completion of sources
1557     */
1558    public void testThenAcceptBothAsync() {
1559        CompletableFuture<Integer> f, g;
1560        CompletableFuture<Void> h;
1561        SubtractAction r;
1562
1563        f = new CompletableFuture<>();
1564        g = new CompletableFuture<>();
1565        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1566        f.complete(3);
1567        checkIncomplete(h);
1568        g.complete(1);
1569        checkCompletedNormally(h, null);
1570        assertEquals(r.value, 2);
1571
1572        f = new CompletableFuture<>();
1573        g = new CompletableFuture<>();
1574        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1575        g.complete(1);
1576        checkIncomplete(h);
1577        f.complete(3);
1578        checkCompletedNormally(h, null);
1579        assertEquals(r.value, 2);
1580
1581        f = new CompletableFuture<>();
1582        g = new CompletableFuture<>();
1583        g.complete(1);
1584        f.complete(3);
1585        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1586        checkCompletedNormally(h, null);
1587        assertEquals(r.value, 2);
1588    }
1589
1590    /**
1591     * thenAcceptBothAsync result completes exceptionally after exceptional
1592     * completion of source
1593     */
1594    public void testThenAcceptBothAsync2() {
1595        CompletableFuture<Integer> f, g;
1596        CompletableFuture<Void> h;
1597        SubtractAction r;
1598
1599        f = new CompletableFuture<>();
1600        g = new CompletableFuture<>();
1601        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1602        f.completeExceptionally(new CFException());
1603        checkIncomplete(h);
1604        g.complete(1);
1605        checkCompletedWithWrappedCFException(h);
1606
1607        f = new CompletableFuture<>();
1608        g = new CompletableFuture<>();
1609        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1610        g.completeExceptionally(new CFException());
1611        checkIncomplete(h);
1612        f.complete(3);
1613        checkCompletedWithWrappedCFException(h);
1614
1615        f = new CompletableFuture<>();
1616        g = new CompletableFuture<>();
1617        f.complete(3);
1618        g.completeExceptionally(new CFException());
1619        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1620        checkCompletedWithWrappedCFException(h);
1621
1622        f = new CompletableFuture<>();
1623        g = new CompletableFuture<>();
1624        f.completeExceptionally(new CFException());
1625        g.complete(3);
1626        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1627        checkCompletedWithWrappedCFException(h);
1628    }
1629
1630    /**
1631     * thenAcceptBothAsync result completes exceptionally if action does
1632     */
1633    public void testThenAcceptBothAsync3() {
1634        CompletableFuture<Integer> f, g;
1635        CompletableFuture<Void> h;
1636        FailingBiConsumer r;
1637
1638        f = new CompletableFuture<>();
1639        g = new CompletableFuture<>();
1640        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1641        f.complete(3);
1642        checkIncomplete(h);
1643        g.complete(1);
1644        checkCompletedWithWrappedCFException(h);
1645
1646        f = new CompletableFuture<>();
1647        g = new CompletableFuture<>();
1648        f.complete(3);
1649        g.complete(1);
1650        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1651        checkCompletedWithWrappedCFException(h);
1652    }
1653
1654    /**
1655     * thenAcceptBothAsync result completes exceptionally if either source cancelled
1656     */
1657    public void testThenAcceptBothAsync4() {
1658        CompletableFuture<Integer> f, g;
1659        CompletableFuture<Void> h;
1660        SubtractAction r;
1661
1662        f = new CompletableFuture<>();
1663        g = new CompletableFuture<>();
1664        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1665        assertTrue(f.cancel(true));
1666        checkIncomplete(h);
1667        g.complete(1);
1668        checkCompletedWithWrappedCancellationException(h);
1669
1670        f = new CompletableFuture<>();
1671        g = new CompletableFuture<>();
1672        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1673        assertTrue(g.cancel(true));
1674        checkIncomplete(h);
1675        f.complete(3);
1676        checkCompletedWithWrappedCancellationException(h);
1677
1678        f = new CompletableFuture<>();
1679        g = new CompletableFuture<>();
1680        f.complete(3);
1681        assertTrue(g.cancel(true));
1682        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1683        checkCompletedWithWrappedCancellationException(h);
1684
1685        f = new CompletableFuture<>();
1686        g = new CompletableFuture<>();
1687        assertTrue(f.cancel(true));
1688        g.complete(3);
1689        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1690        checkCompletedWithWrappedCancellationException(h);
1691    }
1692
1693    /**
1694     * runAfterBothAsync result completes normally after normal
1695     * completion of sources
1696     */
1697    public void testRunAfterBothAsync() {
1698        CompletableFuture<Integer> f = new CompletableFuture<>();
1699        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1700        Noop r = new Noop();
1701        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1702        f.complete(one);
1703        checkIncomplete(g);
1704        f2.complete(two);
1705        checkCompletedNormally(g, null);
1706        assertTrue(r.ran);
1707    }
1708
1709    /**
1710     * runAfterBothAsync result completes exceptionally after exceptional
1711     * completion of source
1712     */
1713    public void testRunAfterBothAsync2() {
1714        CompletableFuture<Integer> f = new CompletableFuture<>();
1715        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1716        Noop r = new Noop();
1717        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1718        f.completeExceptionally(new CFException());
1719        f2.complete(two);
1720        checkCompletedWithWrappedCFException(g);
1721
1722        r = new Noop();
1723        f = new CompletableFuture<>();
1724        f2 = new CompletableFuture<>();
1725        g = f.runAfterBothAsync(f2, r);
1726        f.complete(one);
1727        f2.completeExceptionally(new CFException());
1728        checkCompletedWithWrappedCFException(g);
1729    }
1730
1731    /**
1732     * runAfterBothAsync result completes exceptionally if action does
1733     */
1734    public void testRunAfterBothAsync3() {
1735        CompletableFuture<Integer> f = new CompletableFuture<>();
1736        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1737        FailingNoop r = new FailingNoop();
1738        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1739        f.complete(one);
1740        checkIncomplete(g);
1741        f2.complete(two);
1742        checkCompletedWithWrappedCFException(g);
1743    }
1744
1745    /**
1746     * runAfterBothAsync result completes exceptionally if either source cancelled
1747     */
1748    public void testRunAfterBothAsync4() {
1749        CompletableFuture<Integer> f = new CompletableFuture<>();
1750        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1751        Noop r = new Noop();
1752        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1753        assertTrue(f.cancel(true));
1754        f2.complete(two);
1755        checkCompletedWithWrappedCancellationException(g);
1756
1757        r = new Noop();
1758        f = new CompletableFuture<>();
1759        f2 = new CompletableFuture<>();
1760        g = f.runAfterBothAsync(f2, r);
1761        f.complete(one);
1762        assertTrue(f2.cancel(true));
1763        checkCompletedWithWrappedCancellationException(g);
1764    }
1765
1766    /**
2156       * applyToEitherAsync result completes normally after normal
2157       * completion of sources
2158       */
# Line 2055 | Line 2444 | public class CompletableFutureTest exten
2444          checkCompletedWithWrappedCancellationException(g);
2445      }
2446  
2058
2447      // async with explicit executors
2448  
2449      /**
# Line 2088 | Line 2476 | public class CompletableFutureTest exten
2476          try {
2477              g.join();
2478              shouldThrow();
2479 <        } catch (Exception ok) {
2092 <        }
2479 >        } catch (CompletionException success) {}
2480          checkCompletedWithWrappedCFException(g);
2481      }
2482  
# Line 2205 | Line 2592 | public class CompletableFutureTest exten
2592      }
2593  
2594      /**
2208     * thenCombineAsync result completes normally after normal
2209     * completion of sources
2210     */
2211    public void testThenCombineAsyncE() {
2212        CompletableFuture<Integer> f, g, h;
2213        ThreadExecutor e = new ThreadExecutor();
2214        int count = 0;
2215
2216        f = new CompletableFuture<>();
2217        g = new CompletableFuture<>();
2218        h = f.thenCombineAsync(g, subtract, e);
2219        f.complete(3);
2220        checkIncomplete(h);
2221        g.complete(1);
2222        checkCompletedNormally(h, 2);
2223        assertEquals(++count, e.count.get());
2224
2225        f = new CompletableFuture<>();
2226        g = new CompletableFuture<>();
2227        h = f.thenCombineAsync(g, subtract, e);
2228        g.complete(1);
2229        checkIncomplete(h);
2230        f.complete(3);
2231        checkCompletedNormally(h, 2);
2232        assertEquals(++count, e.count.get());
2233
2234        f = new CompletableFuture<>();
2235        g = new CompletableFuture<>();
2236        g.complete(1);
2237        f.complete(3);
2238        h = f.thenCombineAsync(g, subtract, e);
2239        checkCompletedNormally(h, 2);
2240        assertEquals(++count, e.count.get());
2241    }
2242
2243    /**
2244     * thenCombineAsync result completes exceptionally after exceptional
2245     * completion of either source
2246     */
2247    public void testThenCombineAsync2E() {
2248        CompletableFuture<Integer> f, g, h;
2249        ThreadExecutor e = new ThreadExecutor();
2250        int count = 0;
2251
2252        f = new CompletableFuture<>();
2253        g = new CompletableFuture<>();
2254        h = f.thenCombineAsync(g, subtract, e);
2255        f.completeExceptionally(new CFException());
2256        checkIncomplete(h);
2257        g.complete(1);
2258        checkCompletedWithWrappedCFException(h);
2259
2260        f = new CompletableFuture<>();
2261        g = new CompletableFuture<>();
2262        h = f.thenCombineAsync(g, subtract, e);
2263        g.completeExceptionally(new CFException());
2264        checkIncomplete(h);
2265        f.complete(3);
2266        checkCompletedWithWrappedCFException(h);
2267
2268        f = new CompletableFuture<>();
2269        g = new CompletableFuture<>();
2270        g.completeExceptionally(new CFException());
2271        h = f.thenCombineAsync(g, subtract, e);
2272        checkIncomplete(h);
2273        f.complete(3);
2274        checkCompletedWithWrappedCFException(h);
2275
2276        assertEquals(0, e.count.get());
2277    }
2278
2279    /**
2280     * thenCombineAsync result completes exceptionally if action does
2281     */
2282    public void testThenCombineAsync3E() {
2283        CompletableFuture<Integer> f = new CompletableFuture<>();
2284        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2285        FailingBiFunction r = new FailingBiFunction();
2286        CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
2287        f.complete(one);
2288        checkIncomplete(g);
2289        assertFalse(r.ran);
2290        f2.complete(two);
2291        checkCompletedWithWrappedCFException(g);
2292        assertTrue(r.ran);
2293    }
2294
2295    /**
2296     * thenCombineAsync result completes exceptionally if either source cancelled
2297     */
2298    public void testThenCombineAsync4E() {
2299        CompletableFuture<Integer> f, g, h;
2300        ThreadExecutor e = new ThreadExecutor();
2301
2302        f = new CompletableFuture<>();
2303        g = new CompletableFuture<>();
2304        h = f.thenCombineAsync(g, subtract, e);
2305        assertTrue(f.cancel(true));
2306        checkIncomplete(h);
2307        g.complete(1);
2308        checkCompletedWithWrappedCancellationException(h);
2309
2310        f = new CompletableFuture<>();
2311        g = new CompletableFuture<>();
2312        h = f.thenCombineAsync(g, subtract, e);
2313        assertTrue(g.cancel(true));
2314        checkIncomplete(h);
2315        f.complete(3);
2316        checkCompletedWithWrappedCancellationException(h);
2317
2318        f = new CompletableFuture<>();
2319        g = new CompletableFuture<>();
2320        assertTrue(g.cancel(true));
2321        h = f.thenCombineAsync(g, subtract, e);
2322        checkIncomplete(h);
2323        f.complete(3);
2324        checkCompletedWithWrappedCancellationException(h);
2325
2326        f = new CompletableFuture<>();
2327        g = new CompletableFuture<>();
2328        assertTrue(f.cancel(true));
2329        assertTrue(g.cancel(true));
2330        h = f.thenCombineAsync(g, subtract, e);
2331        checkCompletedWithWrappedCancellationException(h);
2332
2333        assertEquals(0, e.count.get());
2334    }
2335
2336    /**
2337     * thenAcceptBothAsync result completes normally after normal
2338     * completion of sources
2339     */
2340    public void testThenAcceptBothAsyncE() {
2341        CompletableFuture<Integer> f, g;
2342        CompletableFuture<Void> h;
2343        SubtractAction r;
2344        ThreadExecutor e = new ThreadExecutor();
2345
2346        f = new CompletableFuture<>();
2347        g = new CompletableFuture<>();
2348        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2349        f.complete(3);
2350        checkIncomplete(h);
2351        g.complete(1);
2352        checkCompletedNormally(h, null);
2353        assertEquals(r.value, 2);
2354
2355        f = new CompletableFuture<>();
2356        g = new CompletableFuture<>();
2357        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2358        g.complete(1);
2359        checkIncomplete(h);
2360        f.complete(3);
2361        checkCompletedNormally(h, null);
2362        assertEquals(r.value, 2);
2363
2364        f = new CompletableFuture<>();
2365        g = new CompletableFuture<>();
2366        g.complete(1);
2367        f.complete(3);
2368        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2369        checkCompletedNormally(h, null);
2370        assertEquals(r.value, 2);
2371
2372        assertEquals(3, e.count.get());
2373    }
2374
2375    /**
2376     * thenAcceptBothAsync result completes exceptionally after exceptional
2377     * completion of source
2378     */
2379    public void testThenAcceptBothAsync2E() {
2380        CompletableFuture<Integer> f, g;
2381        CompletableFuture<Void> h;
2382        SubtractAction r;
2383        ThreadExecutor e = new ThreadExecutor();
2384
2385        f = new CompletableFuture<>();
2386        g = new CompletableFuture<>();
2387        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2388        f.completeExceptionally(new CFException());
2389        checkIncomplete(h);
2390        g.complete(1);
2391        checkCompletedWithWrappedCFException(h);
2392
2393        f = new CompletableFuture<>();
2394        g = new CompletableFuture<>();
2395        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2396        g.completeExceptionally(new CFException());
2397        checkIncomplete(h);
2398        f.complete(3);
2399        checkCompletedWithWrappedCFException(h);
2400
2401        f = new CompletableFuture<>();
2402        g = new CompletableFuture<>();
2403        f.complete(3);
2404        g.completeExceptionally(new CFException());
2405        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2406        checkCompletedWithWrappedCFException(h);
2407
2408        f = new CompletableFuture<>();
2409        g = new CompletableFuture<>();
2410        f.completeExceptionally(new CFException());
2411        g.complete(3);
2412        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2413        checkCompletedWithWrappedCFException(h);
2414
2415        assertEquals(0, e.count.get());
2416    }
2417
2418    /**
2419     * thenAcceptBothAsync result completes exceptionally if action does
2420     */
2421    public void testThenAcceptBothAsync3E() {
2422        CompletableFuture<Integer> f, g;
2423        CompletableFuture<Void> h;
2424        FailingBiConsumer r;
2425        ThreadExecutor e = new ThreadExecutor();
2426
2427        f = new CompletableFuture<>();
2428        g = new CompletableFuture<>();
2429        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2430        f.complete(3);
2431        checkIncomplete(h);
2432        g.complete(1);
2433        checkCompletedWithWrappedCFException(h);
2434
2435        f = new CompletableFuture<>();
2436        g = new CompletableFuture<>();
2437        f.complete(3);
2438        g.complete(1);
2439        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2440        checkCompletedWithWrappedCFException(h);
2441
2442        assertEquals(2, e.count.get());
2443    }
2444
2445    /**
2446     * thenAcceptBothAsync result completes exceptionally if either source cancelled
2447     */
2448    public void testThenAcceptBothAsync4E() {
2449        CompletableFuture<Integer> f, g;
2450        CompletableFuture<Void> h;
2451        SubtractAction r;
2452        ThreadExecutor e = new ThreadExecutor();
2453
2454        f = new CompletableFuture<>();
2455        g = new CompletableFuture<>();
2456        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2457        assertTrue(f.cancel(true));
2458        checkIncomplete(h);
2459        g.complete(1);
2460        checkCompletedWithWrappedCancellationException(h);
2461
2462        f = new CompletableFuture<>();
2463        g = new CompletableFuture<>();
2464        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2465        assertTrue(g.cancel(true));
2466        checkIncomplete(h);
2467        f.complete(3);
2468        checkCompletedWithWrappedCancellationException(h);
2469
2470        f = new CompletableFuture<>();
2471        g = new CompletableFuture<>();
2472        f.complete(3);
2473        assertTrue(g.cancel(true));
2474        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2475        checkCompletedWithWrappedCancellationException(h);
2476
2477        f = new CompletableFuture<>();
2478        g = new CompletableFuture<>();
2479        assertTrue(f.cancel(true));
2480        g.complete(3);
2481        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2482        checkCompletedWithWrappedCancellationException(h);
2483
2484        assertEquals(0, e.count.get());
2485    }
2486
2487    /**
2488     * runAfterBothAsync result completes normally after normal
2489     * completion of sources
2490     */
2491    public void testRunAfterBothAsyncE() {
2492        CompletableFuture<Integer> f = new CompletableFuture<>();
2493        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2494        Noop r = new Noop();
2495        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2496        f.complete(one);
2497        checkIncomplete(g);
2498        f2.complete(two);
2499        checkCompletedNormally(g, null);
2500        assertTrue(r.ran);
2501    }
2502
2503    /**
2504     * runAfterBothAsync result completes exceptionally after exceptional
2505     * completion of source
2506     */
2507    public void testRunAfterBothAsync2E() {
2508        CompletableFuture<Integer> f = new CompletableFuture<>();
2509        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2510        Noop r = new Noop();
2511        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2512        f.completeExceptionally(new CFException());
2513        f2.complete(two);
2514        checkCompletedWithWrappedCFException(g);
2515
2516        r = new Noop();
2517        f = new CompletableFuture<>();
2518        f2 = new CompletableFuture<>();
2519        g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2520        f.complete(one);
2521        f2.completeExceptionally(new CFException());
2522        checkCompletedWithWrappedCFException(g);
2523    }
2524
2525    /**
2526     * runAfterBothAsync result completes exceptionally if action does
2527     */
2528    public void testRunAfterBothAsync3E() {
2529        CompletableFuture<Integer> f = new CompletableFuture<>();
2530        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2531        FailingNoop r = new FailingNoop();
2532        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2533        f.complete(one);
2534        checkIncomplete(g);
2535        f2.complete(two);
2536        checkCompletedWithWrappedCFException(g);
2537    }
2538
2539    /**
2540     * runAfterBothAsync result completes exceptionally if either source cancelled
2541     */
2542    public void testRunAfterBothAsync4E() {
2543        CompletableFuture<Integer> f = new CompletableFuture<>();
2544        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2545        Noop r = new Noop();
2546        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2547        assertTrue(f.cancel(true));
2548        f2.complete(two);
2549        checkCompletedWithWrappedCancellationException(g);
2550
2551        r = new Noop();
2552        f = new CompletableFuture<>();
2553        f2 = new CompletableFuture<>();
2554        g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2555        f.complete(one);
2556        assertTrue(f2.cancel(true));
2557        checkCompletedWithWrappedCancellationException(g);
2558    }
2559
2560    /**
2595       * applyToEitherAsync result completes normally after normal
2596       * completion of sources
2597       */
# Line 2826 | Line 2860 | public class CompletableFutureTest exten
2860       * with the value null
2861       */
2862      public void testAllOf_empty() throws Exception {
2863 <        CompletableFuture<?> f = CompletableFuture.allOf();
2863 >        CompletableFuture<Void> f = CompletableFuture.allOf();
2864          checkCompletedNormally(f, null);
2865      }
2866  
2867      /**
2868 <     * allOf returns a future completed when all components complete
2868 >     * allOf returns a future completed normally with the value null
2869 >     * when all components complete normally
2870       */
2871 <    public void testAllOf() throws Exception {
2871 >    public void testAllOf_normal() throws Exception {
2872          for (int k = 1; k < 20; ++k) {
2873              CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2874              for (int i = 0; i < k; ++i)
# Line 2841 | Line 2876 | public class CompletableFutureTest exten
2876              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2877              for (int i = 0; i < k; ++i) {
2878                  checkIncomplete(f);
2879 +                checkIncomplete(CompletableFuture.allOf(fs));
2880                  fs[i].complete(one);
2881              }
2882              checkCompletedNormally(f, null);
2883 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
2884          }
2885      }
2886  
# Line 2851 | Line 2888 | public class CompletableFutureTest exten
2888       * anyOf(no component futures) returns an incomplete future
2889       */
2890      public void testAnyOf_empty() throws Exception {
2891 <        CompletableFuture<?> f = CompletableFuture.anyOf();
2891 >        CompletableFuture<Object> f = CompletableFuture.anyOf();
2892          checkIncomplete(f);
2893      }
2894  
2895      /**
2896 <     * anyOf returns a future completed when any components complete
2896 >     * anyOf returns a future completed normally with a value when
2897 >     * a component future does
2898       */
2899 <    public void testAnyOf() throws Exception {
2900 <        for (int k = 1; k < 20; ++k) {
2899 >    public void testAnyOf_normal() throws Exception {
2900 >        for (int k = 0; k < 10; ++k) {
2901              CompletableFuture[] fs = new CompletableFuture[k];
2902              for (int i = 0; i < k; ++i)
2903                  fs[i] = new CompletableFuture<>();
# Line 2868 | Line 2906 | public class CompletableFutureTest exten
2906              for (int i = 0; i < k; ++i) {
2907                  fs[i].complete(one);
2908                  checkCompletedNormally(f, one);
2909 +                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
2910 +            }
2911 +        }
2912 +    }
2913 +
2914 +    /**
2915 +     * anyOf result completes exceptionally when any component does.
2916 +     */
2917 +    public void testAnyOf_exceptional() throws Exception {
2918 +        for (int k = 0; k < 10; ++k) {
2919 +            CompletableFuture[] fs = new CompletableFuture[k];
2920 +            for (int i = 0; i < k; ++i)
2921 +                fs[i] = new CompletableFuture<>();
2922 +            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
2923 +            checkIncomplete(f);
2924 +            for (int i = 0; i < k; ++i) {
2925 +                fs[i].completeExceptionally(new CFException());
2926 +                checkCompletedWithWrappedCFException(f);
2927 +                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
2928              }
2929          }
2930      }
# Line 2883 | Line 2940 | public class CompletableFutureTest exten
2940          ThreadExecutor exec = new ThreadExecutor();
2941  
2942          Runnable[] throwingActions = {
2943 <            () -> { CompletableFuture.supplyAsync(null); },
2944 <            () -> { CompletableFuture.supplyAsync(null, exec); },
2945 <            () -> { CompletableFuture.supplyAsync(supplyOne, null); },
2946 <
2947 <            () -> { CompletableFuture.runAsync(null); },
2948 <            () -> { CompletableFuture.runAsync(null, exec); },
2949 <            () -> { CompletableFuture.runAsync(() -> {}, null); },
2950 <
2951 <            () -> { f.completeExceptionally(null); },
2952 <
2953 <            () -> { f.thenApply(null); },
2954 <            () -> { f.thenApplyAsync(null); },
2955 <            () -> { f.thenApplyAsync((x) -> x, null); },
2956 <            () -> { f.thenApplyAsync(null, exec); },
2957 <
2958 <            () -> { f.thenAccept(null); },
2959 <            () -> { f.thenAcceptAsync(null); },
2960 <            () -> { f.thenAcceptAsync((x) -> { ; }, null); },
2961 <            () -> { f.thenAcceptAsync(null, exec); },
2962 <
2963 <            () -> { f.thenRun(null); },
2964 <            () -> { f.thenRunAsync(null); },
2965 <            () -> { f.thenRunAsync(() -> { ; }, null); },
2966 <            () -> { f.thenRunAsync(null, exec); },
2967 <
2968 <            () -> { f.thenCombine(g, null); },
2969 <            () -> { f.thenCombineAsync(g, null); },
2970 <            () -> { f.thenCombineAsync(g, null, exec); },
2971 <            () -> { f.thenCombine(nullFuture, (x, y) -> x); },
2972 <            () -> { f.thenCombineAsync(nullFuture, (x, y) -> x); },
2973 <            () -> { f.thenCombineAsync(nullFuture, (x, y) -> x, exec); },
2974 <            () -> { f.thenCombineAsync(g, (x, y) -> x, null); },
2975 <
2976 <            () -> { f.thenAcceptBoth(g, null); },
2977 <            () -> { f.thenAcceptBothAsync(g, null); },
2978 <            () -> { f.thenAcceptBothAsync(g, null, exec); },
2979 <            () -> { f.thenAcceptBoth(nullFuture, (x, y) -> {}); },
2980 <            () -> { f.thenAcceptBothAsync(nullFuture, (x, y) -> {}); },
2981 <            () -> { f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec); },
2982 <            () -> { f.thenAcceptBothAsync(g, (x, y) -> {}, null); },
2983 <
2984 <            () -> { f.runAfterBoth(g, null); },
2985 <            () -> { f.runAfterBothAsync(g, null); },
2986 <            () -> { f.runAfterBothAsync(g, null, exec); },
2987 <            () -> { f.runAfterBoth(nullFuture, () -> {}); },
2988 <            () -> { f.runAfterBothAsync(nullFuture, () -> {}); },
2989 <            () -> { f.runAfterBothAsync(nullFuture, () -> {}, exec); },
2990 <            () -> { f.runAfterBothAsync(g, () -> {}, null); },
2991 <
2992 <            () -> { f.applyToEither(g, null); },
2993 <            () -> { f.applyToEitherAsync(g, null); },
2994 <            () -> { f.applyToEitherAsync(g, null, exec); },
2995 <            () -> { f.applyToEither(nullFuture, (x) -> x); },
2996 <            () -> { f.applyToEitherAsync(nullFuture, (x) -> x); },
2997 <            () -> { f.applyToEitherAsync(nullFuture, (x) -> x, exec); },
2998 <            () -> { f.applyToEitherAsync(g, (x) -> x, null); },
2999 <
3000 <            () -> { f.acceptEither(g, null); },
3001 <            () -> { f.acceptEitherAsync(g, null); },
3002 <            () -> { f.acceptEitherAsync(g, null, exec); },
3003 <            () -> { f.acceptEither(nullFuture, (x) -> {}); },
3004 <            () -> { f.acceptEitherAsync(nullFuture, (x) -> {}); },
3005 <            () -> { f.acceptEitherAsync(nullFuture, (x) -> {}, exec); },
3006 <            () -> { f.acceptEitherAsync(g, (x) -> {}, null); },
3007 <
3008 <            () -> { f.runAfterEither(g, null); },
3009 <            () -> { f.runAfterEitherAsync(g, null); },
3010 <            () -> { f.runAfterEitherAsync(g, null, exec); },
3011 <            () -> { f.runAfterEither(nullFuture, () -> {}); },
3012 <            () -> { f.runAfterEitherAsync(nullFuture, () -> {}); },
3013 <            () -> { f.runAfterEitherAsync(nullFuture, () -> {}, exec); },
3014 <            () -> { f.runAfterEitherAsync(g, () -> {}, null); },
3015 <
3016 <            () -> { f.thenCompose(null); },
3017 <            () -> { f.thenComposeAsync(null); },
3018 <            () -> { f.thenComposeAsync(new CompletableFutureInc(), null); },
3019 <            () -> { f.thenComposeAsync(null, exec); },
3020 <
3021 <            () -> { f.exceptionally(null); },
3022 <
3023 <            () -> { f.handle(null); },
3024 <
3025 <            () -> { CompletableFuture.allOf((CompletableFuture<?>)null); },
3026 <            () -> { CompletableFuture.allOf((CompletableFuture<?>[])null); },
3027 <            () -> { CompletableFuture.allOf(f, null); },
3028 <            () -> { CompletableFuture.allOf(null, f); },
3029 <
3030 <            () -> { CompletableFuture.anyOf((CompletableFuture<?>)null); },
3031 <            () -> { CompletableFuture.anyOf((CompletableFuture<?>[])null); },
3032 <            () -> { CompletableFuture.anyOf(f, null); },
3033 <            () -> { CompletableFuture.anyOf(null, f); },
2943 >            () -> CompletableFuture.supplyAsync(null),
2944 >            () -> CompletableFuture.supplyAsync(null, exec),
2945 >            () -> CompletableFuture.supplyAsync(supplyOne, null),
2946 >
2947 >            () -> CompletableFuture.runAsync(null),
2948 >            () -> CompletableFuture.runAsync(null, exec),
2949 >            () -> CompletableFuture.runAsync(() -> {}, null),
2950 >
2951 >            () -> f.completeExceptionally(null),
2952 >
2953 >            () -> f.thenApply(null),
2954 >            () -> f.thenApplyAsync(null),
2955 >            () -> f.thenApplyAsync((x) -> x, null),
2956 >            () -> f.thenApplyAsync(null, exec),
2957 >
2958 >            () -> f.thenAccept(null),
2959 >            () -> f.thenAcceptAsync(null),
2960 >            () -> f.thenAcceptAsync((x) -> {} , null),
2961 >            () -> f.thenAcceptAsync(null, exec),
2962 >
2963 >            () -> f.thenRun(null),
2964 >            () -> f.thenRunAsync(null),
2965 >            () -> f.thenRunAsync(() -> {} , null),
2966 >            () -> f.thenRunAsync(null, exec),
2967 >
2968 >            () -> f.thenCombine(g, null),
2969 >            () -> f.thenCombineAsync(g, null),
2970 >            () -> f.thenCombineAsync(g, null, exec),
2971 >            () -> f.thenCombine(nullFuture, (x, y) -> x),
2972 >            () -> f.thenCombineAsync(nullFuture, (x, y) -> x),
2973 >            () -> f.thenCombineAsync(nullFuture, (x, y) -> x, exec),
2974 >            () -> f.thenCombineAsync(g, (x, y) -> x, null),
2975 >
2976 >            () -> f.thenAcceptBoth(g, null),
2977 >            () -> f.thenAcceptBothAsync(g, null),
2978 >            () -> f.thenAcceptBothAsync(g, null, exec),
2979 >            () -> f.thenAcceptBoth(nullFuture, (x, y) -> {}),
2980 >            () -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}),
2981 >            () -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec),
2982 >            () -> f.thenAcceptBothAsync(g, (x, y) -> {}, null),
2983 >
2984 >            () -> f.runAfterBoth(g, null),
2985 >            () -> f.runAfterBothAsync(g, null),
2986 >            () -> f.runAfterBothAsync(g, null, exec),
2987 >            () -> f.runAfterBoth(nullFuture, () -> {}),
2988 >            () -> f.runAfterBothAsync(nullFuture, () -> {}),
2989 >            () -> f.runAfterBothAsync(nullFuture, () -> {}, exec),
2990 >            () -> f.runAfterBothAsync(g, () -> {}, null),
2991 >
2992 >            () -> f.applyToEither(g, null),
2993 >            () -> f.applyToEitherAsync(g, null),
2994 >            () -> f.applyToEitherAsync(g, null, exec),
2995 >            () -> f.applyToEither(nullFuture, (x) -> x),
2996 >            () -> f.applyToEitherAsync(nullFuture, (x) -> x),
2997 >            () -> f.applyToEitherAsync(nullFuture, (x) -> x, exec),
2998 >            () -> f.applyToEitherAsync(g, (x) -> x, null),
2999 >
3000 >            () -> f.acceptEither(g, null),
3001 >            () -> f.acceptEitherAsync(g, null),
3002 >            () -> f.acceptEitherAsync(g, null, exec),
3003 >            () -> f.acceptEither(nullFuture, (x) -> {}),
3004 >            () -> f.acceptEitherAsync(nullFuture, (x) -> {}),
3005 >            () -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec),
3006 >            () -> f.acceptEitherAsync(g, (x) -> {}, null),
3007 >
3008 >            () -> f.runAfterEither(g, null),
3009 >            () -> f.runAfterEitherAsync(g, null),
3010 >            () -> f.runAfterEitherAsync(g, null, exec),
3011 >            () -> f.runAfterEither(nullFuture, () -> {}),
3012 >            () -> f.runAfterEitherAsync(nullFuture, () -> {}),
3013 >            () -> f.runAfterEitherAsync(nullFuture, () -> {}, exec),
3014 >            () -> f.runAfterEitherAsync(g, () -> {}, null),
3015 >
3016 >            () -> f.thenCompose(null),
3017 >            () -> f.thenComposeAsync(null),
3018 >            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
3019 >            () -> f.thenComposeAsync(null, exec),
3020 >
3021 >            () -> f.exceptionally(null),
3022 >
3023 >            () -> f.handle(null),
3024 >
3025 >            () -> CompletableFuture.allOf((CompletableFuture<?>)null),
3026 >            () -> CompletableFuture.allOf((CompletableFuture<?>[])null),
3027 >            () -> CompletableFuture.allOf(f, null),
3028 >            () -> CompletableFuture.allOf(null, f),
3029 >
3030 >            () -> CompletableFuture.anyOf((CompletableFuture<?>)null),
3031 >            () -> CompletableFuture.anyOf((CompletableFuture<?>[])null),
3032 >            () -> CompletableFuture.anyOf(f, null),
3033 >            () -> CompletableFuture.anyOf(null, f),
3034 >
3035 >            () -> f.obtrudeException(null),
3036          };
3037  
3038          assertThrows(NullPointerException.class, throwingActions);
3039          assertEquals(0, exec.count.get());
3040      }
3041  
3042 +    /**
3043 +     * toCompletableFuture returns this CompletableFuture.
3044 +     */
3045 +    public void testToCompletableFuture() {
3046 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3047 +        assertSame(f, f.toCompletableFuture());
3048 +    }
3049 +
3050 +    /**
3051 +     * whenComplete action executes on normal completion, propagating
3052 +     * source result.
3053 +     */
3054 +    public void testWhenComplete1() {
3055 +        final AtomicInteger a = new AtomicInteger();
3056 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3057 +        CompletableFuture<Integer> g =
3058 +            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3059 +        f.complete(three);
3060 +        checkCompletedNormally(f, three);
3061 +        checkCompletedNormally(g, three);
3062 +        assertEquals(a.get(), 1);
3063 +    }
3064 +
3065 +    /**
3066 +     * whenComplete action executes on exceptional completion, propagating
3067 +     * source result.
3068 +     */
3069 +    public void testWhenComplete2() {
3070 +        final AtomicInteger a = new AtomicInteger();
3071 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3072 +        CompletableFuture<Integer> g =
3073 +            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3074 +        f.completeExceptionally(new CFException());
3075 +        assertTrue(f.isCompletedExceptionally());
3076 +        assertTrue(g.isCompletedExceptionally());
3077 +        assertEquals(a.get(), 1);
3078 +    }
3079 +
3080 +    /**
3081 +     * If a whenComplete action throws an exception when triggered by
3082 +     * a normal completion, it completes exceptionally
3083 +     */
3084 +    public void testWhenComplete3() {
3085 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3086 +        CompletableFuture<Integer> g =
3087 +            f.whenComplete((Integer x, Throwable t) ->
3088 +                           { throw new CFException(); } );
3089 +        f.complete(three);
3090 +        checkCompletedNormally(f, three);
3091 +        assertTrue(g.isCompletedExceptionally());
3092 +        checkCompletedWithWrappedCFException(g);
3093 +    }
3094 +
3095 +    /**
3096 +     * whenCompleteAsync action executes on normal completion, propagating
3097 +     * source result.
3098 +     */
3099 +    public void testWhenCompleteAsync1() {
3100 +        final AtomicInteger a = new AtomicInteger();
3101 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3102 +        CompletableFuture<Integer> g =
3103 +            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3104 +        f.complete(three);
3105 +        checkCompletedNormally(f, three);
3106 +        checkCompletedNormally(g, three);
3107 +        assertEquals(a.get(), 1);
3108 +    }
3109 +
3110 +    /**
3111 +     * whenCompleteAsync action executes on exceptional completion, propagating
3112 +     * source result.
3113 +     */
3114 +    public void testWhenCompleteAsync2() {
3115 +        final AtomicInteger a = new AtomicInteger();
3116 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3117 +        CompletableFuture<Integer> g =
3118 +            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3119 +        f.completeExceptionally(new CFException());
3120 +        checkCompletedWithWrappedCFException(f);
3121 +        checkCompletedWithWrappedCFException(g);
3122 +    }
3123 +
3124 +    /**
3125 +     * If a whenCompleteAsync action throws an exception when
3126 +     * triggered by a normal completion, it completes exceptionally
3127 +     */
3128 +    public void testWhenCompleteAsync3() {
3129 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3130 +        CompletableFuture<Integer> g =
3131 +            f.whenCompleteAsync((Integer x, Throwable t) ->
3132 +                           { throw new CFException(); } );
3133 +        f.complete(three);
3134 +        checkCompletedNormally(f, three);
3135 +        checkCompletedWithWrappedCFException(g);
3136 +    }
3137 +
3138 +    /**
3139 +     * whenCompleteAsync action executes on normal completion, propagating
3140 +     * source result.
3141 +     */
3142 +    public void testWhenCompleteAsync1e() {
3143 +        final AtomicInteger a = new AtomicInteger();
3144 +        ThreadExecutor exec = new ThreadExecutor();
3145 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3146 +        CompletableFuture<Integer> g =
3147 +            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3148 +                                exec);
3149 +        f.complete(three);
3150 +        checkCompletedNormally(f, three);
3151 +        checkCompletedNormally(g, three);
3152 +        assertEquals(a.get(), 1);
3153 +    }
3154 +
3155 +    /**
3156 +     * whenCompleteAsync action executes on exceptional completion, propagating
3157 +     * source result.
3158 +     */
3159 +    public void testWhenCompleteAsync2e() {
3160 +        final AtomicInteger a = new AtomicInteger();
3161 +        ThreadExecutor exec = new ThreadExecutor();
3162 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3163 +        CompletableFuture<Integer> g =
3164 +            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3165 +                                exec);
3166 +        f.completeExceptionally(new CFException());
3167 +        checkCompletedWithWrappedCFException(f);
3168 +        checkCompletedWithWrappedCFException(g);
3169 +    }
3170 +
3171 +    /**
3172 +     * If a whenCompleteAsync action throws an exception when triggered
3173 +     * by a normal completion, it completes exceptionally
3174 +     */
3175 +    public void testWhenCompleteAsync3e() {
3176 +        ThreadExecutor exec = new ThreadExecutor();
3177 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3178 +        CompletableFuture<Integer> g =
3179 +            f.whenCompleteAsync((Integer x, Throwable t) ->
3180 +                                { throw new CFException(); },
3181 +                                exec);
3182 +        f.complete(three);
3183 +        checkCompletedNormally(f, three);
3184 +        checkCompletedWithWrappedCFException(g);
3185 +    }
3186 +
3187 +    /**
3188 +     * handleAsync action completes normally with function value on
3189 +     * either normal or exceptional completion of source
3190 +     */
3191 +    public void testHandleAsync() {
3192 +        CompletableFuture<Integer> f, g;
3193 +        IntegerHandler r;
3194 +
3195 +        f = new CompletableFuture<>();
3196 +        g = f.handleAsync(r = new IntegerHandler());
3197 +        assertFalse(r.ran);
3198 +        f.completeExceptionally(new CFException());
3199 +        checkCompletedWithWrappedCFException(f);
3200 +        checkCompletedNormally(g, three);
3201 +        assertTrue(r.ran);
3202 +
3203 +        f = new CompletableFuture<>();
3204 +        g = f.handleAsync(r = new IntegerHandler());
3205 +        assertFalse(r.ran);
3206 +        f.completeExceptionally(new CFException());
3207 +        checkCompletedWithWrappedCFException(f);
3208 +        checkCompletedNormally(g, three);
3209 +        assertTrue(r.ran);
3210 +
3211 +        f = new CompletableFuture<>();
3212 +        g = f.handleAsync(r = new IntegerHandler());
3213 +        assertFalse(r.ran);
3214 +        f.complete(one);
3215 +        checkCompletedNormally(f, one);
3216 +        checkCompletedNormally(g, two);
3217 +        assertTrue(r.ran);
3218 +
3219 +        f = new CompletableFuture<>();
3220 +        g = f.handleAsync(r = new IntegerHandler());
3221 +        assertFalse(r.ran);
3222 +        f.complete(one);
3223 +        checkCompletedNormally(f, one);
3224 +        checkCompletedNormally(g, two);
3225 +        assertTrue(r.ran);
3226 +    }
3227 +
3228 +    /**
3229 +     * handleAsync action with Executor completes normally with
3230 +     * function value on either normal or exceptional completion of
3231 +     * source
3232 +     */
3233 +    public void testHandleAsync2() {
3234 +        CompletableFuture<Integer> f, g;
3235 +        ThreadExecutor exec = new ThreadExecutor();
3236 +        IntegerHandler r;
3237 +
3238 +        f = new CompletableFuture<>();
3239 +        g = f.handleAsync(r = new IntegerHandler(), exec);
3240 +        assertFalse(r.ran);
3241 +        f.completeExceptionally(new CFException());
3242 +        checkCompletedWithWrappedCFException(f);
3243 +        checkCompletedNormally(g, three);
3244 +        assertTrue(r.ran);
3245 +
3246 +        f = new CompletableFuture<>();
3247 +        g = f.handleAsync(r = new IntegerHandler(), exec);
3248 +        assertFalse(r.ran);
3249 +        f.completeExceptionally(new CFException());
3250 +        checkCompletedWithWrappedCFException(f);
3251 +        checkCompletedNormally(g, three);
3252 +        assertTrue(r.ran);
3253 +
3254 +        f = new CompletableFuture<>();
3255 +        g = f.handleAsync(r = new IntegerHandler(), exec);
3256 +        assertFalse(r.ran);
3257 +        f.complete(one);
3258 +        checkCompletedNormally(f, one);
3259 +        checkCompletedNormally(g, two);
3260 +        assertTrue(r.ran);
3261 +
3262 +        f = new CompletableFuture<>();
3263 +        g = f.handleAsync(r = new IntegerHandler(), exec);
3264 +        assertFalse(r.ran);
3265 +        f.complete(one);
3266 +        checkCompletedNormally(f, one);
3267 +        checkCompletedNormally(g, two);
3268 +        assertTrue(r.ran);
3269 +    }
3270 +
3271   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines