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.43 by jsr166, Mon Jun 2 04:13:54 2014 UTC vs.
Revision 1.54 by jsr166, Mon Jun 2 21:32:24 2014 UTC

# Line 17 | Line 17 | import java.util.concurrent.Future;
17   import java.util.concurrent.CompletableFuture;
18   import java.util.concurrent.CompletionException;
19   import java.util.concurrent.CompletionStage;
20 + import java.util.concurrent.ForkJoinPool;
21 + import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.TimeoutException;
23   import java.util.concurrent.atomic.AtomicInteger;
24   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 247 | Line 249 | public class CompletableFutureTest exten
249          f = new CompletableFuture<>();
250          f.obtrudeValue(three);
251          checkCompletedNormally(f, three);
252 +        f.obtrudeValue(null);
253 +        checkCompletedNormally(f, null);
254          f = new CompletableFuture<>();
255          f.completeExceptionally(new CFException());
256          f.obtrudeValue(four);
# Line 279 | Line 283 | public class CompletableFutureTest exten
283       */
284      public void testGetNumberOfDependents() {
285          CompletableFuture<Integer> f = new CompletableFuture<>();
286 <        assertEquals(f.getNumberOfDependents(), 0);
286 >        assertEquals(0, f.getNumberOfDependents());
287          CompletableFuture g = f.thenRun(new Noop());
288 <        assertEquals(f.getNumberOfDependents(), 1);
289 <        assertEquals(g.getNumberOfDependents(), 0);
288 >        assertEquals(1, f.getNumberOfDependents());
289 >        assertEquals(0, g.getNumberOfDependents());
290          CompletableFuture h = f.thenRun(new Noop());
291 <        assertEquals(f.getNumberOfDependents(), 2);
291 >        assertEquals(2, f.getNumberOfDependents());
292          f.complete(1);
293          checkCompletedNormally(g, null);
294 <        assertEquals(f.getNumberOfDependents(), 0);
295 <        assertEquals(g.getNumberOfDependents(), 0);
294 >        assertEquals(0, f.getNumberOfDependents());
295 >        assertEquals(0, g.getNumberOfDependents());
296      }
297  
298      /**
# Line 339 | Line 343 | public class CompletableFutureTest exten
343      static final class IncAction implements Consumer<Integer> {
344          int invocationCount = 0;
345          Integer value;
342        public boolean ran() { return invocationCount == 1; }
346          public void accept(Integer x) {
347              invocationCount++;
348              value = inc(x);
# Line 348 | Line 351 | public class CompletableFutureTest exten
351      static final class IncFunction implements Function<Integer,Integer> {
352          int invocationCount = 0;
353          Integer value;
351        public boolean ran() { return invocationCount == 1; }
354          public Integer apply(Integer x) {
355              invocationCount++;
356              return value = inc(x);
# Line 358 | Line 360 | public class CompletableFutureTest exten
360          int invocationCount = 0;
361          Integer value;
362          // Check this action was invoked exactly once when result is computed.
361        public boolean ran() { return invocationCount == 1; }
363          public void accept(Integer x, Integer y) {
364              invocationCount++;
365              value = subtract(x, y);
# Line 368 | Line 369 | public class CompletableFutureTest exten
369          int invocationCount = 0;
370          Integer value;
371          // Check this action was invoked exactly once when result is computed.
371        public boolean ran() { return invocationCount == 1; }
372          public Integer apply(Integer x, Integer y) {
373              invocationCount++;
374              return value = subtract(x, y);
# Line 376 | Line 376 | public class CompletableFutureTest exten
376      }
377      static final class Noop implements Runnable {
378          int invocationCount = 0;
379        boolean ran;
379          public void run() {
380              invocationCount++;
382            ran = true;
381          }
382      }
383  
384      static final class FailingSupplier implements Supplier<Integer> {
385 <        boolean ran;
386 <        public Integer get() { ran = true; throw new CFException(); }
385 >        int invocationCount = 0;
386 >        public Integer get() {
387 >            invocationCount++;
388 >            throw new CFException();
389 >        }
390      }
391      static final class FailingConsumer implements Consumer<Integer> {
392 <        boolean ran;
393 <        public void accept(Integer x) { ran = true; throw new CFException(); }
392 >        int invocationCount = 0;
393 >        public void accept(Integer x) {
394 >            invocationCount++;
395 >            throw new CFException();
396 >        }
397      }
398      static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
399 <        boolean ran;
400 <        public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
399 >        int invocationCount = 0;
400 >        public void accept(Integer x, Integer y) {
401 >            invocationCount++;
402 >            throw new CFException();
403 >        }
404      }
405      static final class FailingFunction implements Function<Integer, Integer> {
406 <        boolean ran;
407 <        public Integer apply(Integer x) { ran = true; throw new CFException(); }
406 >        int invocationCount = 0;
407 >        public Integer apply(Integer x) {
408 >            invocationCount++;
409 >            throw new CFException();
410 >        }
411      }
412      static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
413 <        boolean ran;
414 <        public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
413 >        int invocationCount = 0;
414 >        public Integer apply(Integer x, Integer y) {
415 >            invocationCount++;
416 >            throw new CFException();
417 >        }
418      }
419 <    static final class FailingNoop implements Runnable {
420 <        boolean ran;
421 <        public void run() { ran = true; throw new CFException(); }
419 >    static final class FailingRunnable implements Runnable {
420 >        int invocationCount = 0;
421 >        public void run() {
422 >            invocationCount++;
423 >            throw new CFException();
424 >        }
425      }
426  
427      static final class CompletableFutureInc
428          implements Function<Integer, CompletableFuture<Integer>> {
429 <        boolean ran;
429 >        int invocationCount = 0;
430          public CompletableFuture<Integer> apply(Integer x) {
431 <            ran = true;
431 >            invocationCount++;
432              CompletableFuture<Integer> f = new CompletableFuture<>();
433 <            f.complete(Integer.valueOf(x.intValue() + 1));
433 >            f.complete(inc(x));
434              return f;
435          }
436      }
437  
438      static final class FailingCompletableFutureFunction
439          implements Function<Integer, CompletableFuture<Integer>> {
440 <        boolean ran;
440 >        int invocationCount = 0;
441          public CompletableFuture<Integer> apply(Integer x) {
442 <            ran = true; throw new CFException();
442 >            invocationCount++;
443 >            throw new CFException();
444          }
445      }
446  
# Line 437 | Line 454 | public class CompletableFutureTest exten
454          }
455      }
456  
440    static final class ExceptionToInteger implements Function<Throwable, Integer> {
441        public Integer apply(Throwable x) { return Integer.valueOf(3); }
442    }
443
444    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
445        boolean ran;
446        public Integer apply(Integer x, Throwable t) {
447            ran = true;
448            return (t == null) ? two : three;
449        }
450    }
451
457      /**
458       * Permits the testing of parallel code for the 3 different
459       * execution modes without repeating all the testing code.
460       */
461      enum ExecutionMode {
462          DEFAULT {
463 +            public void checkExecutionMode() {
464 +                assertNull(ForkJoinTask.getPool());
465 +            }
466 +            public <T> CompletableFuture<Void> thenRun
467 +                (CompletableFuture<T> f, Runnable a) {
468 +                return f.thenRun(a);
469 +            }
470 +            public <T> CompletableFuture<Void> thenAccept
471 +                (CompletableFuture<T> f, Consumer<? super T> a) {
472 +                return f.thenAccept(a);
473 +            }
474 +            public <T,U> CompletableFuture<U> thenApply
475 +                (CompletableFuture<T> f, Function<? super T,U> a) {
476 +                return f.thenApply(a);
477 +            }
478 +            public <T,U> CompletableFuture<U> thenCompose
479 +                (CompletableFuture<T> f,
480 +                 Function<? super T,? extends CompletionStage<U>> a) {
481 +                return f.thenCompose(a);
482 +            }
483 +            public <T,U> CompletableFuture<U> handle
484 +                (CompletableFuture<T> f,
485 +                 BiFunction<? super T,Throwable,? extends U> a) {
486 +                return f.handle(a);
487 +            }
488 +            public <T> CompletableFuture<T> whenComplete
489 +                (CompletableFuture<T> f,
490 +                 BiConsumer<? super T,? super Throwable> a) {
491 +                return f.whenComplete(a);
492 +            }
493              public <T,U> CompletableFuture<Void> runAfterBoth
494                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
495                  return f.runAfterBoth(g, a);
# Line 471 | Line 506 | public class CompletableFutureTest exten
506                   BiFunction<? super T,? super U,? extends V> a) {
507                  return f.thenCombine(g, a);
508              }
509 <            public <T,U> CompletableFuture<U> applyToEither
509 >            public <T> CompletableFuture<Void> runAfterEither
510                  (CompletableFuture<T> f,
511 <                 CompletionStage<? extends T> g,
512 <                 Function<? super T,U> a) {
513 <                return f.applyToEither(g, a);
511 >                 CompletionStage<?> g,
512 >                 java.lang.Runnable a) {
513 >                return f.runAfterEither(g, a);
514              }
515              public <T> CompletableFuture<Void> acceptEither
516                  (CompletableFuture<T> f,
# Line 483 | Line 518 | public class CompletableFutureTest exten
518                   Consumer<? super T> a) {
519                  return f.acceptEither(g, a);
520              }
521 <            public <T> CompletableFuture<Void> runAfterEither
521 >            public <T,U> CompletableFuture<U> applyToEither
522                  (CompletableFuture<T> f,
523 <                 CompletionStage<?> g,
524 <                 java.lang.Runnable a) {
525 <                return f.runAfterEither(g, a);
523 >                 CompletionStage<? extends T> g,
524 >                 Function<? super T,U> a) {
525 >                return f.applyToEither(g, a);
526 >            }
527 >        },
528 >
529 >        ASYNC {
530 >            public void checkExecutionMode() {
531 >                assertSame(ForkJoinPool.commonPool(),
532 >                           ForkJoinTask.getPool());
533 >            }
534 >            public <T> CompletableFuture<Void> thenRun
535 >                (CompletableFuture<T> f, Runnable a) {
536 >                return f.thenRunAsync(a);
537 >            }
538 >            public <T> CompletableFuture<Void> thenAccept
539 >                (CompletableFuture<T> f, Consumer<? super T> a) {
540 >                return f.thenAcceptAsync(a);
541 >            }
542 >            public <T,U> CompletableFuture<U> thenApply
543 >                (CompletableFuture<T> f, Function<? super T,U> a) {
544 >                return f.thenApplyAsync(a);
545              }
546              public <T,U> CompletableFuture<U> thenCompose
547                  (CompletableFuture<T> f,
548                   Function<? super T,? extends CompletionStage<U>> a) {
549 <                return f.thenCompose(a);
549 >                return f.thenComposeAsync(a);
550 >            }
551 >            public <T,U> CompletableFuture<U> handle
552 >                (CompletableFuture<T> f,
553 >                 BiFunction<? super T,Throwable,? extends U> a) {
554 >                return f.handleAsync(a);
555              }
556              public <T> CompletableFuture<T> whenComplete
557                  (CompletableFuture<T> f,
558                   BiConsumer<? super T,? super Throwable> a) {
559 <                return f.whenComplete(a);
559 >                return f.whenCompleteAsync(a);
560              }
502        },
503
504 //             /** Experimental way to do more testing */
505 //         REVERSE_DEFAULT {
506 //             public <T,U> CompletableFuture<Void> runAfterBoth
507 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
508 //                 return g.runAfterBoth(f, a);
509 //             }
510 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
511 //                 (CompletableFuture<T> f,
512 //                  CompletionStage<? extends U> g,
513 //                  BiConsumer<? super T,? super U> a) {
514 //                 return DEFAULT.thenAcceptBoth(f, g, a);
515 //             }
516 //         },
517
518        DEFAULT_ASYNC {
561              public <T,U> CompletableFuture<Void> runAfterBoth
562                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
563                  return f.runAfterBothAsync(g, a);
# Line 532 | Line 574 | public class CompletableFutureTest exten
574                   BiFunction<? super T,? super U,? extends V> a) {
575                  return f.thenCombineAsync(g, a);
576              }
577 <            public <T,U> CompletableFuture<U> applyToEither
577 >            public <T> CompletableFuture<Void> runAfterEither
578                  (CompletableFuture<T> f,
579 <                 CompletionStage<? extends T> g,
580 <                 Function<? super T,U> a) {
581 <                return f.applyToEitherAsync(g, a);
579 >                 CompletionStage<?> g,
580 >                 java.lang.Runnable a) {
581 >                return f.runAfterEitherAsync(g, a);
582              }
583              public <T> CompletableFuture<Void> acceptEither
584                  (CompletableFuture<T> f,
# Line 544 | Line 586 | public class CompletableFutureTest exten
586                   Consumer<? super T> a) {
587                  return f.acceptEitherAsync(g, a);
588              }
589 <            public <T> CompletableFuture<Void> runAfterEither
589 >            public <T,U> CompletableFuture<U> applyToEither
590                  (CompletableFuture<T> f,
591 <                 CompletionStage<?> g,
592 <                 java.lang.Runnable a) {
593 <                return f.runAfterEitherAsync(g, a);
591 >                 CompletionStage<? extends T> g,
592 >                 Function<? super T,U> a) {
593 >                return f.applyToEitherAsync(g, a);
594 >            }
595 >        },
596 >
597 >        EXECUTOR {
598 >            public void checkExecutionMode() {
599 >                //TODO
600 >            }
601 >            public <T> CompletableFuture<Void> thenRun
602 >                (CompletableFuture<T> f, Runnable a) {
603 >                return f.thenRunAsync(a, new ThreadExecutor());
604 >            }
605 >            public <T> CompletableFuture<Void> thenAccept
606 >                (CompletableFuture<T> f, Consumer<? super T> a) {
607 >                return f.thenAcceptAsync(a, new ThreadExecutor());
608 >            }
609 >            public <T,U> CompletableFuture<U> thenApply
610 >                (CompletableFuture<T> f, Function<? super T,U> a) {
611 >                return f.thenApplyAsync(a, new ThreadExecutor());
612              }
613              public <T,U> CompletableFuture<U> thenCompose
614                  (CompletableFuture<T> f,
615                   Function<? super T,? extends CompletionStage<U>> a) {
616 <                return f.thenComposeAsync(a);
616 >                return f.thenComposeAsync(a, new ThreadExecutor());
617 >            }
618 >            public <T,U> CompletableFuture<U> handle
619 >                (CompletableFuture<T> f,
620 >                 BiFunction<? super T,Throwable,? extends U> a) {
621 >                return f.handleAsync(a, new ThreadExecutor());
622              }
623              public <T> CompletableFuture<T> whenComplete
624                  (CompletableFuture<T> f,
625                   BiConsumer<? super T,? super Throwable> a) {
626 <                return f.whenCompleteAsync(a);
626 >                return f.whenCompleteAsync(a, new ThreadExecutor());
627              }
563        },
564
565 //         REVERSE_DEFAULT_ASYNC {
566 //             public <T,U> CompletableFuture<Void> runAfterBoth
567 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
568 //                 return f.runAfterBothAsync(g, a);
569 //             }
570 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
571 //                 (CompletableFuture<T> f,
572 //                  CompletionStage<? extends U> g,
573 //                  BiConsumer<? super T,? super U> a) {
574 //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
575 //             }
576 //         },
577
578        EXECUTOR {
628              public <T,U> CompletableFuture<Void> runAfterBoth
629                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
630                  return f.runAfterBothAsync(g, a, new ThreadExecutor());
# Line 592 | Line 641 | public class CompletableFutureTest exten
641                   BiFunction<? super T,? super U,? extends V> a) {
642                  return f.thenCombineAsync(g, a, new ThreadExecutor());
643              }
595            public <T,U> CompletableFuture<U> applyToEither
596                (CompletableFuture<T> f,
597                 CompletionStage<? extends T> g,
598                 Function<? super T,U> a) {
599                return f.applyToEitherAsync(g, a, new ThreadExecutor());
600            }
601            public <T> CompletableFuture<Void> acceptEither
602                (CompletableFuture<T> f,
603                 CompletionStage<? extends T> g,
604                 Consumer<? super T> a) {
605                return f.acceptEitherAsync(g, a, new ThreadExecutor());
606            }
644              public <T> CompletableFuture<Void> runAfterEither
645                  (CompletableFuture<T> f,
646                   CompletionStage<?> g,
647                   java.lang.Runnable a) {
648                  return f.runAfterEitherAsync(g, a, new ThreadExecutor());
649              }
650 <            public <T,U> CompletableFuture<U> thenCompose
650 >            public <T> CompletableFuture<Void> acceptEither
651                  (CompletableFuture<T> f,
652 <                 Function<? super T,? extends CompletionStage<U>> a) {
653 <                return f.thenComposeAsync(a, new ThreadExecutor());
652 >                 CompletionStage<? extends T> g,
653 >                 Consumer<? super T> a) {
654 >                return f.acceptEitherAsync(g, a, new ThreadExecutor());
655              }
656 <            public <T> CompletableFuture<T> whenComplete
656 >            public <T,U> CompletableFuture<U> applyToEither
657                  (CompletableFuture<T> f,
658 <                 BiConsumer<? super T,? super Throwable> a) {
659 <                return f.whenCompleteAsync(a, new ThreadExecutor());
658 >                 CompletionStage<? extends T> g,
659 >                 Function<? super T,U> a) {
660 >                return f.applyToEitherAsync(g, a, new ThreadExecutor());
661              }
662          };
663  
664 +        public abstract void checkExecutionMode();
665 +        public abstract <T> CompletableFuture<Void> thenRun
666 +            (CompletableFuture<T> f, Runnable a);
667 +        public abstract <T> CompletableFuture<Void> thenAccept
668 +            (CompletableFuture<T> f, Consumer<? super T> a);
669 +        public abstract <T,U> CompletableFuture<U> thenApply
670 +            (CompletableFuture<T> f, Function<? super T,U> a);
671 +        public abstract <T,U> CompletableFuture<U> thenCompose
672 +            (CompletableFuture<T> f,
673 +             Function<? super T,? extends CompletionStage<U>> a);
674 +        public abstract <T,U> CompletableFuture<U> handle
675 +            (CompletableFuture<T> f,
676 +             BiFunction<? super T,Throwable,? extends U> a);
677 +        public abstract <T> CompletableFuture<T> whenComplete
678 +            (CompletableFuture<T> f,
679 +             BiConsumer<? super T,? super Throwable> a);
680          public abstract <T,U> CompletableFuture<Void> runAfterBoth
681              (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
682          public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
# Line 632 | Line 687 | public class CompletableFutureTest exten
687              (CompletableFuture<T> f,
688               CompletionStage<? extends U> g,
689               BiFunction<? super T,? super U,? extends V> a);
635        public abstract <T,U> CompletableFuture<U> applyToEither
636            (CompletableFuture<T> f,
637             CompletionStage<? extends T> g,
638             Function<? super T,U> a);
639        public abstract <T> CompletableFuture<Void> acceptEither
640            (CompletableFuture<T> f,
641             CompletionStage<? extends T> g,
642             Consumer<? super T> a);
690          public abstract <T> CompletableFuture<Void> runAfterEither
691              (CompletableFuture<T> f,
692               CompletionStage<?> g,
693               java.lang.Runnable a);
694 <        public abstract <T,U> CompletableFuture<U> thenCompose
694 >        public abstract <T> CompletableFuture<Void> acceptEither
695              (CompletableFuture<T> f,
696 <             Function<? super T,? extends CompletionStage<U>> a);
697 <        public abstract <T> CompletableFuture<T> whenComplete
696 >             CompletionStage<? extends T> g,
697 >             Consumer<? super T> a);
698 >        public abstract <T,U> CompletableFuture<U> applyToEither
699              (CompletableFuture<T> f,
700 <             BiConsumer<? super T,? super Throwable> a);
700 >             CompletionStage<? extends T> g,
701 >             Function<? super T,U> a);
702 >    }
703  
704 +    /**
705 +     * exceptionally action is not invoked when source completes
706 +     * normally, and source result is propagated
707 +     */
708 +    public void testExceptionally_normalCompletion() {
709 +        for (boolean createIncomplete : new boolean[] { true, false })
710 +        for (Integer v1 : new Integer[] { 1, null })
711 +    {
712 +        final AtomicInteger a = new AtomicInteger(0);
713 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
714 +        if (!createIncomplete) f.complete(v1);
715 +        final CompletableFuture<Integer> g = f.exceptionally
716 +            ((Throwable t) -> {
717 +                // Should not be called
718 +                a.getAndIncrement();
719 +                throw new AssertionError();
720 +            });
721 +        if (createIncomplete) f.complete(v1);
722 +
723 +        checkCompletedNormally(g, v1);
724 +        checkCompletedNormally(f, v1);
725 +        assertEquals(0, a.get());
726 +    }}
727  
655    }
728  
729      /**
730       * exceptionally action completes with function value on source
731 <     * exception; otherwise with source value
731 >     * exception
732       */
733 <    public void testExceptionally() {
734 <        CompletableFuture<Integer> f = new CompletableFuture<>();
735 <        ExceptionToInteger r = new ExceptionToInteger();
736 <        CompletableFuture<Integer> g = f.exceptionally(r);
737 <        f.completeExceptionally(new CFException());
738 <        checkCompletedNormally(g, three);
733 >    public void testExceptionally_exceptionalCompletion() {
734 >        for (boolean createIncomplete : new boolean[] { true, false })
735 >        for (Integer v1 : new Integer[] { 1, null })
736 >    {
737 >        final AtomicInteger a = new AtomicInteger(0);
738 >        final CFException ex = new CFException();
739 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
740 >        if (!createIncomplete) f.completeExceptionally(ex);
741 >        final CompletableFuture<Integer> g = f.exceptionally
742 >            ((Throwable t) -> {
743 >                threadAssertSame(t, ex);
744 >                a.getAndIncrement();
745 >                return v1;
746 >            });
747 >        if (createIncomplete) f.completeExceptionally(ex);
748  
749 <        f = new CompletableFuture<>();
750 <        r = new ExceptionToInteger();
751 <        g = f.exceptionally(r);
752 <        f.complete(one);
753 <        checkCompletedNormally(g, one);
754 <    }
749 >        checkCompletedNormally(g, v1);
750 >        assertEquals(1, a.get());
751 >    }}
752 >
753 >    public void testExceptionally_exceptionalCompletionActionFailed() {
754 >        for (boolean createIncomplete : new boolean[] { true, false })
755 >        for (Integer v1 : new Integer[] { 1, null })
756 >    {
757 >        final AtomicInteger a = new AtomicInteger(0);
758 >        final CFException ex1 = new CFException();
759 >        final CFException ex2 = new CFException();
760 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
761 >        if (!createIncomplete) f.completeExceptionally(ex1);
762 >        final CompletableFuture<Integer> g = f.exceptionally
763 >            ((Throwable t) -> {
764 >                threadAssertSame(t, ex1);
765 >                a.getAndIncrement();
766 >                throw ex2;
767 >            });
768 >        if (createIncomplete) f.completeExceptionally(ex1);
769 >
770 >        checkCompletedWithWrappedCFException(g, ex2);
771 >        assertEquals(1, a.get());
772 >    }}
773  
774      /**
775 <     * handle action completes normally with function value on either
776 <     * normal or exceptional completion of source
775 >     * handle action completes normally with function value on normal
776 >     * completion of source
777       */
778 <    public void testHandle() {
779 <        CompletableFuture<Integer> f, g;
780 <        IntegerHandler r;
778 >    public void testHandle_normalCompletion() {
779 >        for (ExecutionMode m : ExecutionMode.values())
780 >        for (boolean createIncomplete : new boolean[] { true, false })
781 >        for (Integer v1 : new Integer[] { 1, null })
782 >    {
783 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
784 >        final AtomicInteger a = new AtomicInteger(0);
785 >        if (!createIncomplete) f.complete(v1);
786 >        final CompletableFuture<Integer> g = m.handle
787 >            (f,
788 >             (Integer x, Throwable t) -> {
789 >                threadAssertSame(x, v1);
790 >                threadAssertNull(t);
791 >                a.getAndIncrement();
792 >                return inc(v1);
793 >            });
794 >        if (createIncomplete) f.complete(v1);
795  
796 <        f = new CompletableFuture<>();
797 <        f.completeExceptionally(new CFException());
798 <        g = f.handle(r = new IntegerHandler());
799 <        assertTrue(r.ran);
687 <        checkCompletedNormally(g, three);
796 >        checkCompletedNormally(g, inc(v1));
797 >        checkCompletedNormally(f, v1);
798 >        assertEquals(1, a.get());
799 >    }}
800  
801 <        f = new CompletableFuture<>();
802 <        g = f.handle(r = new IntegerHandler());
803 <        assertFalse(r.ran);
804 <        f.completeExceptionally(new CFException());
805 <        checkCompletedNormally(g, three);
806 <        assertTrue(r.ran);
801 >    /**
802 >     * handle action completes normally with function value on
803 >     * exceptional completion of source
804 >     */
805 >    public void testHandle_exceptionalCompletion() {
806 >        for (ExecutionMode m : ExecutionMode.values())
807 >        for (boolean createIncomplete : new boolean[] { true, false })
808 >        for (Integer v1 : new Integer[] { 1, null })
809 >    {
810 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
811 >        final AtomicInteger a = new AtomicInteger(0);
812 >        final CFException ex = new CFException();
813 >        if (!createIncomplete) f.completeExceptionally(ex);
814 >        final CompletableFuture<Integer> g = m.handle
815 >            (f,
816 >             (Integer x, Throwable t) -> {
817 >                threadAssertNull(x);
818 >                threadAssertSame(t, ex);
819 >                a.getAndIncrement();
820 >                return v1;
821 >            });
822 >        if (createIncomplete) f.completeExceptionally(ex);
823  
824 <        f = new CompletableFuture<>();
825 <        f.complete(one);
826 <        g = f.handle(r = new IntegerHandler());
827 <        assertTrue(r.ran);
700 <        checkCompletedNormally(g, two);
824 >        checkCompletedNormally(g, v1);
825 >        checkCompletedWithWrappedCFException(f, ex);
826 >        assertEquals(1, a.get());
827 >    }}
828  
829 <        f = new CompletableFuture<>();
830 <        g = f.handle(r = new IntegerHandler());
831 <        assertFalse(r.ran);
832 <        f.complete(one);
833 <        assertTrue(r.ran);
834 <        checkCompletedNormally(g, two);
835 <    }
829 >    /**
830 >     * handle action completes normally with function value on
831 >     * cancelled source
832 >     */
833 >    public void testHandle_sourceCancelled() {
834 >        for (ExecutionMode m : ExecutionMode.values())
835 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
836 >        for (boolean createIncomplete : new boolean[] { true, false })
837 >        for (Integer v1 : new Integer[] { 1, null })
838 >    {
839 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
840 >        final AtomicInteger a = new AtomicInteger(0);
841 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
842 >        final CompletableFuture<Integer> g = m.handle
843 >            (f,
844 >             (Integer x, Throwable t) -> {
845 >                threadAssertNull(x);
846 >                threadAssertTrue(t instanceof CancellationException);
847 >                a.getAndIncrement();
848 >                return v1;
849 >            });
850 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
851 >
852 >        checkCompletedNormally(g, v1);
853 >        checkCancelled(f);
854 >        assertEquals(1, a.get());
855 >    }}
856 >
857 >    /**
858 >     * handle result completes exceptionally if action does
859 >     */
860 >    public void testHandle_sourceFailedActionFailed() {
861 >        for (ExecutionMode m : ExecutionMode.values())
862 >        for (boolean createIncomplete : new boolean[] { true, false })
863 >    {
864 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
865 >        final AtomicInteger a = new AtomicInteger(0);
866 >        final CFException ex1 = new CFException();
867 >        final CFException ex2 = new CFException();
868 >        if (!createIncomplete) f.completeExceptionally(ex1);
869 >        final CompletableFuture<Integer> g = m.handle
870 >            (f,
871 >             (Integer x, Throwable t) -> {
872 >                threadAssertNull(x);
873 >                threadAssertSame(ex1, t);
874 >                a.getAndIncrement();
875 >                throw ex2;
876 >            });
877 >        if (createIncomplete) f.completeExceptionally(ex1);
878 >
879 >        checkCompletedWithWrappedCFException(g, ex2);
880 >        checkCompletedWithWrappedCFException(f, ex1);
881 >        assertEquals(1, a.get());
882 >    }}
883 >
884 >    public void testHandle_sourceCompletedNormallyActionFailed() {
885 >        for (ExecutionMode m : ExecutionMode.values())
886 >        for (boolean createIncomplete : new boolean[] { true, false })
887 >        for (Integer v1 : new Integer[] { 1, null })
888 >    {
889 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
890 >        final AtomicInteger a = new AtomicInteger(0);
891 >        final CFException ex = new CFException();
892 >        if (!createIncomplete) f.complete(v1);
893 >        final CompletableFuture<Integer> g = m.handle
894 >            (f,
895 >             (Integer x, Throwable t) -> {
896 >                threadAssertSame(x, v1);
897 >                threadAssertNull(t);
898 >                a.getAndIncrement();
899 >                throw ex;
900 >            });
901 >        if (createIncomplete) f.complete(v1);
902 >
903 >        checkCompletedWithWrappedCFException(g, ex);
904 >        checkCompletedNormally(f, v1);
905 >        assertEquals(1, a.get());
906 >    }}
907  
908      /**
909       * runAsync completes after running Runnable
# Line 714 | Line 912 | public class CompletableFutureTest exten
912          Noop r = new Noop();
913          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
914          assertNull(f.join());
915 <        assertTrue(r.ran);
915 >        assertEquals(1, r.invocationCount);
916          checkCompletedNormally(f, null);
917      }
918  
# Line 726 | Line 924 | public class CompletableFutureTest exten
924          ThreadExecutor exec = new ThreadExecutor();
925          CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
926          assertNull(f.join());
927 <        assertTrue(r.ran);
927 >        assertEquals(1, r.invocationCount);
928          checkCompletedNormally(f, null);
929          assertEquals(1, exec.count.get());
930      }
# Line 735 | Line 933 | public class CompletableFutureTest exten
933       * failing runAsync completes exceptionally after running Runnable
934       */
935      public void testRunAsync3() {
936 <        FailingNoop r = new FailingNoop();
936 >        FailingRunnable r = new FailingRunnable();
937          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
938          checkCompletedWithWrappedCFException(f);
939 <        assertTrue(r.ran);
939 >        assertEquals(1, r.invocationCount);
940      }
941  
942      /**
# Line 768 | Line 966 | public class CompletableFutureTest exten
966          FailingSupplier r = new FailingSupplier();
967          CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
968          checkCompletedWithWrappedCFException(f);
969 <        assertTrue(r.ran);
969 >        assertEquals(1, r.invocationCount);
970      }
971  
972      // seq completion methods
# Line 776 | Line 974 | public class CompletableFutureTest exten
974      /**
975       * thenRun result completes normally after normal completion of source
976       */
977 <    public void testThenRun() {
978 <        CompletableFuture<Integer> f;
979 <        CompletableFuture<Void> g;
980 <        Noop r;
981 <
982 <        f = new CompletableFuture<>();
983 <        g = f.thenRun(r = new Noop());
984 <        f.complete(null);
985 <        checkCompletedNormally(g, null);
986 <        assertTrue(r.ran);
977 >    public void testThenRun_normalCompletion() {
978 >        for (ExecutionMode m : ExecutionMode.values())
979 >        for (boolean createIncomplete : new boolean[] { true, false })
980 >        for (Integer v1 : new Integer[] { 1, null })
981 >    {
982 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
983 >        final Noop r = new Noop();
984 >        if (!createIncomplete) f.complete(v1);
985 >        final CompletableFuture<Void> g = m.thenRun(f, r);
986 >        if (createIncomplete) {
987 >            checkIncomplete(g);
988 >            f.complete(v1);
989 >        }
990  
790        f = new CompletableFuture<>();
791        f.complete(null);
792        g = f.thenRun(r = new Noop());
991          checkCompletedNormally(g, null);
992 <        assertTrue(r.ran);
993 <    }
992 >        checkCompletedNormally(f, v1);
993 >        assertEquals(1, r.invocationCount);
994 >    }}
995  
996      /**
997       * thenRun result completes exceptionally after exceptional
998       * completion of source
999       */
1000 <    public void testThenRun2() {
1001 <        CompletableFuture<Integer> f;
1002 <        CompletableFuture<Void> g;
1003 <        Noop r;
1004 <
1005 <        f = new CompletableFuture<>();
1006 <        g = f.thenRun(r = new Noop());
1007 <        f.completeExceptionally(new CFException());
1008 <        checkCompletedWithWrappedCFException(g);
1009 <        assertFalse(r.ran);
1000 >    public void testThenRun_exceptionalCompletion() {
1001 >        for (ExecutionMode m : ExecutionMode.values())
1002 >        for (boolean createIncomplete : new boolean[] { true, false })
1003 >    {
1004 >        final CFException ex = new CFException();
1005 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1006 >        final Noop r = new Noop();
1007 >        if (!createIncomplete) f.completeExceptionally(ex);
1008 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1009 >        if (createIncomplete) {
1010 >            checkIncomplete(g);
1011 >            f.completeExceptionally(ex);
1012 >        }
1013  
1014 <        f = new CompletableFuture<>();
1015 <        f.completeExceptionally(new CFException());
1016 <        g = f.thenRun(r = new Noop());
1017 <        checkCompletedWithWrappedCFException(g);
816 <        assertFalse(r.ran);
817 <    }
1014 >        checkCompletedWithWrappedCFException(g, ex);
1015 >        checkCompletedWithWrappedCFException(f, ex);
1016 >        assertEquals(0, r.invocationCount);
1017 >    }}
1018  
1019      /**
1020 <     * thenRun result completes exceptionally if action does
1020 >     * thenRun result completes exceptionally if source cancelled
1021       */
1022 <    public void testThenRun3() {
1023 <        CompletableFuture<Integer> f;
1024 <        CompletableFuture<Void> g;
1025 <        FailingNoop r;
1026 <
1027 <        f = new CompletableFuture<>();
1028 <        g = f.thenRun(r = new FailingNoop());
1029 <        f.complete(null);
1030 <        checkCompletedWithWrappedCFException(g);
1022 >    public void testThenRun_sourceCancelled() {
1023 >        for (ExecutionMode m : ExecutionMode.values())
1024 >        for (boolean createIncomplete : new boolean[] { true, false })
1025 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1026 >    {
1027 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1028 >        final Noop r = new Noop();
1029 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1030 >        final CompletableFuture<Void> g = f.thenRun(r);
1031 >        if (createIncomplete) {
1032 >            checkIncomplete(g);
1033 >            assertTrue(f.cancel(mayInterruptIfRunning));
1034 >        }
1035  
1036 <        f = new CompletableFuture<>();
1037 <        f.complete(null);
1038 <        g = f.thenRun(r = new FailingNoop());
1039 <        checkCompletedWithWrappedCFException(g);
836 <    }
1036 >        checkCompletedWithWrappedCancellationException(g);
1037 >        checkCancelled(f);
1038 >        assertEquals(0, r.invocationCount);
1039 >    }}
1040  
1041      /**
1042 <     * thenRun result completes exceptionally if source cancelled
1042 >     * thenRun result completes exceptionally if action does
1043       */
1044 <    public void testThenRun4() {
1045 <        CompletableFuture<Integer> f;
1046 <        CompletableFuture<Void> g;
1047 <        Noop r;
1048 <
1049 <        f = new CompletableFuture<>();
1050 <        g = f.thenRun(r = new Noop());
1051 <        assertTrue(f.cancel(true));
1052 <        checkCompletedWithWrappedCancellationException(g);
1044 >    public void testThenRun_actionFailed() {
1045 >        for (ExecutionMode m : ExecutionMode.values())
1046 >        for (boolean createIncomplete : new boolean[] { true, false })
1047 >        for (Integer v1 : new Integer[] { 1, null })
1048 >    {
1049 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1050 >        final FailingRunnable r = new FailingRunnable();
1051 >        if (!createIncomplete) f.complete(v1);
1052 >        final CompletableFuture<Void> g = f.thenRun(r);
1053 >        if (createIncomplete) {
1054 >            checkIncomplete(g);
1055 >            f.complete(v1);
1056 >        }
1057  
1058 <        f = new CompletableFuture<>();
1059 <        assertTrue(f.cancel(true));
1060 <        g = f.thenRun(r = new Noop());
854 <        checkCompletedWithWrappedCancellationException(g);
855 <    }
1058 >        checkCompletedWithWrappedCFException(g);
1059 >        checkCompletedNormally(f, v1);
1060 >    }}
1061  
1062      /**
1063       * thenApply result completes normally after normal completion of source
1064       */
1065 <    public void testThenApply() {
1066 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1067 <        CompletableFuture<Integer> g = f.thenApply(inc);
1068 <        f.complete(one);
1069 <        checkCompletedNormally(g, two);
1070 <    }
1065 >    public void testThenApply_normalCompletion() {
1066 >        for (ExecutionMode m : ExecutionMode.values())
1067 >        for (boolean createIncomplete : new boolean[] { true, false })
1068 >        for (Integer v1 : new Integer[] { 1, null })
1069 >    {
1070 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1071 >        final IncFunction r = new IncFunction();
1072 >        if (!createIncomplete) f.complete(v1);
1073 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1074 >        if (createIncomplete) {
1075 >            checkIncomplete(g);
1076 >            f.complete(v1);
1077 >        }
1078 >
1079 >        checkCompletedNormally(g, inc(v1));
1080 >        checkCompletedNormally(f, v1);
1081 >        assertEquals(1, r.invocationCount);
1082 >    }}
1083  
1084      /**
1085       * thenApply result completes exceptionally after exceptional
1086       * completion of source
1087       */
1088 <    public void testThenApply2() {
1089 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1090 <        CompletableFuture<Integer> g = f.thenApply(inc);
1091 <        f.completeExceptionally(new CFException());
1092 <        checkCompletedWithWrappedCFException(g);
1093 <    }
1088 >    public void testThenApply_exceptionalCompletion() {
1089 >        for (ExecutionMode m : ExecutionMode.values())
1090 >        for (boolean createIncomplete : new boolean[] { true, false })
1091 >    {
1092 >        final CFException ex = new CFException();
1093 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1094 >        final IncFunction r = new IncFunction();
1095 >        if (!createIncomplete) f.completeExceptionally(ex);
1096 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1097 >        if (createIncomplete) {
1098 >            checkIncomplete(g);
1099 >            f.completeExceptionally(ex);
1100 >        }
1101  
1102 <    /**
1103 <     * thenApply result completes exceptionally if action does
1104 <     */
1105 <    public void testThenApply3() {
882 <        CompletableFuture<Integer> f = new CompletableFuture<>();
883 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
884 <        f.complete(one);
885 <        checkCompletedWithWrappedCFException(g);
886 <    }
1102 >        checkCompletedWithWrappedCFException(g, ex);
1103 >        checkCompletedWithWrappedCFException(f, ex);
1104 >        assertEquals(0, r.invocationCount);
1105 >    }}
1106  
1107      /**
1108       * thenApply result completes exceptionally if source cancelled
1109       */
1110 <    public void testThenApply4() {
1111 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1112 <        CompletableFuture<Integer> g = f.thenApply(inc);
1113 <        assertTrue(f.cancel(true));
1110 >    public void testThenApply_sourceCancelled() {
1111 >        for (ExecutionMode m : ExecutionMode.values())
1112 >        for (boolean createIncomplete : new boolean[] { true, false })
1113 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1114 >    {
1115 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1116 >        final IncFunction r = new IncFunction();
1117 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1118 >        final CompletableFuture<Integer> g = f.thenApply(r);
1119 >        if (createIncomplete) {
1120 >            checkIncomplete(g);
1121 >            assertTrue(f.cancel(mayInterruptIfRunning));
1122 >        }
1123 >
1124          checkCompletedWithWrappedCancellationException(g);
1125 <    }
1125 >        checkCancelled(f);
1126 >        assertEquals(0, r.invocationCount);
1127 >    }}
1128 >
1129 >    /**
1130 >     * thenApply result completes exceptionally if action does
1131 >     */
1132 >    public void testThenApply_actionFailed() {
1133 >        for (ExecutionMode m : ExecutionMode.values())
1134 >        for (boolean createIncomplete : new boolean[] { true, false })
1135 >        for (Integer v1 : new Integer[] { 1, null })
1136 >    {
1137 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1138 >        final FailingFunction r = new FailingFunction();
1139 >        if (!createIncomplete) f.complete(v1);
1140 >        final CompletableFuture<Integer> g = f.thenApply(r);
1141 >        if (createIncomplete) {
1142 >            checkIncomplete(g);
1143 >            f.complete(v1);
1144 >        }
1145 >
1146 >        checkCompletedWithWrappedCFException(g);
1147 >        checkCompletedNormally(f, v1);
1148 >    }}
1149  
1150      /**
1151       * thenAccept result completes normally after normal completion of source
1152       */
1153 <    public void testThenAccept() {
1154 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1155 <        IncAction r = new IncAction();
1156 <        CompletableFuture<Void> g = f.thenAccept(r);
1157 <        f.complete(one);
1153 >    public void testThenAccept_normalCompletion() {
1154 >        for (ExecutionMode m : ExecutionMode.values())
1155 >        for (boolean createIncomplete : new boolean[] { true, false })
1156 >        for (Integer v1 : new Integer[] { 1, null })
1157 >    {
1158 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1159 >        final IncAction r = new IncAction();
1160 >        if (!createIncomplete) f.complete(v1);
1161 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1162 >        if (createIncomplete) {
1163 >            checkIncomplete(g);
1164 >            f.complete(v1);
1165 >        }
1166 >
1167          checkCompletedNormally(g, null);
1168 <        assertEquals(r.value, (Integer) 2);
1169 <    }
1168 >        checkCompletedNormally(f, v1);
1169 >        assertEquals(1, r.invocationCount);
1170 >        assertEquals(inc(v1), r.value);
1171 >    }}
1172  
1173      /**
1174       * thenAccept result completes exceptionally after exceptional
1175       * completion of source
1176       */
1177 <    public void testThenAccept2() {
1178 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1179 <        IncAction r = new IncAction();
1180 <        CompletableFuture<Void> g = f.thenAccept(r);
1181 <        f.completeExceptionally(new CFException());
1182 <        checkCompletedWithWrappedCFException(g);
1183 <    }
1177 >    public void testThenAccept_exceptionalCompletion() {
1178 >        for (ExecutionMode m : ExecutionMode.values())
1179 >        for (boolean createIncomplete : new boolean[] { true, false })
1180 >    {
1181 >        final CFException ex = new CFException();
1182 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1183 >        final IncAction r = new IncAction();
1184 >        if (!createIncomplete) f.completeExceptionally(ex);
1185 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1186 >        if (createIncomplete) {
1187 >            checkIncomplete(g);
1188 >            f.completeExceptionally(ex);
1189 >        }
1190 >
1191 >        checkCompletedWithWrappedCFException(g, ex);
1192 >        checkCompletedWithWrappedCFException(f, ex);
1193 >        assertEquals(0, r.invocationCount);
1194 >    }}
1195  
1196      /**
1197       * thenAccept result completes exceptionally if action does
1198       */
1199 <    public void testThenAccept3() {
1200 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1201 <        FailingConsumer r = new FailingConsumer();
1202 <        CompletableFuture<Void> g = f.thenAccept(r);
1203 <        f.complete(one);
1199 >    public void testThenAccept_actionFailed() {
1200 >        for (ExecutionMode m : ExecutionMode.values())
1201 >        for (boolean createIncomplete : new boolean[] { true, false })
1202 >        for (Integer v1 : new Integer[] { 1, null })
1203 >    {
1204 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1205 >        final FailingConsumer r = new FailingConsumer();
1206 >        if (!createIncomplete) f.complete(v1);
1207 >        final CompletableFuture<Void> g = f.thenAccept(r);
1208 >        if (createIncomplete) {
1209 >            checkIncomplete(g);
1210 >            f.complete(v1);
1211 >        }
1212 >
1213          checkCompletedWithWrappedCFException(g);
1214 <        assertTrue(r.ran);
1215 <    }
1214 >        checkCompletedNormally(f, v1);
1215 >    }}
1216  
1217      /**
1218       * thenAccept result completes exceptionally if source cancelled
1219       */
1220 <    public void testThenAccept4() {
1221 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1222 <        IncAction r = new IncAction();
1223 <        CompletableFuture<Void> g = f.thenAccept(r);
1224 <        assertTrue(f.cancel(true));
1220 >    public void testThenAccept_sourceCancelled() {
1221 >        for (ExecutionMode m : ExecutionMode.values())
1222 >        for (boolean createIncomplete : new boolean[] { true, false })
1223 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1224 >    {
1225 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1226 >        final IncAction r = new IncAction();
1227 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1228 >        final CompletableFuture<Void> g = f.thenAccept(r);
1229 >        if (createIncomplete) {
1230 >            checkIncomplete(g);
1231 >            assertTrue(f.cancel(mayInterruptIfRunning));
1232 >        }
1233 >
1234          checkCompletedWithWrappedCancellationException(g);
1235 <    }
1235 >        checkCancelled(f);
1236 >        assertEquals(0, r.invocationCount);
1237 >    }}
1238  
1239      /**
1240       * thenCombine result completes normally after normal completion
1241       * of sources
1242       */
1243 <    public void testThenCombine_normalCompletion1() {
950 <        for (boolean createdIncomplete : new boolean[] { true, false })
951 <        for (boolean fFirst : new boolean[] { true, false })
1243 >    public void testThenCombine_normalCompletion() {
1244          for (ExecutionMode m : ExecutionMode.values())
1245 +        for (boolean createIncomplete : new boolean[] { true, false })
1246 +        for (boolean fFirst : new boolean[] { true, false })
1247          for (Integer v1 : new Integer[] { 1, null })
1248 <        for (Integer v2 : new Integer[] { 2, null }) {
1249 <
1248 >        for (Integer v2 : new Integer[] { 2, null })
1249 >    {
1250          final CompletableFuture<Integer> f = new CompletableFuture<>();
1251          final CompletableFuture<Integer> g = new CompletableFuture<>();
1252          final SubtractFunction r = new SubtractFunction();
959        CompletableFuture<Integer> h = null;
960        if (createdIncomplete) h = m.thenCombine(f, g, r);
1253  
1254 <        if (fFirst)
1255 <            f.complete(v1);
1256 <        else
1257 <            g.complete(v2);
1258 <        if (createdIncomplete) checkIncomplete(h);
1259 <        assertEquals(r.invocationCount, 0);
1260 <        if (!fFirst)
1261 <            f.complete(v1);
1262 <        else
971 <            g.complete(v2);
972 <        if (!createdIncomplete) h = m.thenCombine(f, g, r);
1254 >        if (fFirst) f.complete(v1); else g.complete(v2);
1255 >        if (!createIncomplete)
1256 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1257 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1258 >        if (createIncomplete) {
1259 >            checkIncomplete(h);
1260 >            assertEquals(0, r.invocationCount);
1261 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1262 >        }
1263  
1264          checkCompletedNormally(h, subtract(v1, v2));
1265          checkCompletedNormally(f, v1);
1266          checkCompletedNormally(g, v2);
1267 <        assertEquals(r.invocationCount, 1);
1268 <        }
979 <    }
1267 >        assertEquals(1, r.invocationCount);
1268 >    }}
1269  
1270      /**
1271       * thenCombine result completes exceptionally after exceptional
1272       * completion of either source
1273       */
1274 <    public void testThenCombine_exceptionalCompletion1() {
1274 >    public void testThenCombine_exceptionalCompletion() {
1275          for (ExecutionMode m : ExecutionMode.values())
1276 <        for (Integer v1 : new Integer[] { 1, null }) {
1277 <
1276 >        for (boolean createIncomplete : new boolean[] { true, false })
1277 >        for (boolean fFirst : new boolean[] { true, false })
1278 >        for (Integer v1 : new Integer[] { 1, null })
1279 >    {
1280          final CompletableFuture<Integer> f = new CompletableFuture<>();
1281          final CompletableFuture<Integer> g = new CompletableFuture<>();
991        final SubtractFunction r = new SubtractFunction();
992        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1282          final CFException ex = new CFException();
994
995        f.completeExceptionally(ex);
996        checkIncomplete(h);
997        g.complete(v1);
998
999        checkCompletedWithWrappedCFException(h, ex);
1000        checkCompletedWithWrappedCFException(f, ex);
1001        assertEquals(r.invocationCount, 0);
1002        checkCompletedNormally(g, v1);
1003        }
1004    }
1005
1006    public void testThenCombine_exceptionalCompletion2() {
1007        for (ExecutionMode m : ExecutionMode.values())
1008        for (Integer v1 : new Integer[] { 1, null }) {
1009
1010        final CompletableFuture<Integer> f = new CompletableFuture<>();
1011        final CompletableFuture<Integer> g = new CompletableFuture<>();
1283          final SubtractFunction r = new SubtractFunction();
1013        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1014        final CFException ex = new CFException();
1015
1016        g.completeExceptionally(ex);
1017        checkIncomplete(h);
1018        f.complete(v1);
1284  
1285 <        checkCompletedWithWrappedCFException(h, ex);
1286 <        checkCompletedWithWrappedCFException(g, ex);
1287 <        assertEquals(r.invocationCount, 0);
1023 <        checkCompletedNormally(f, v1);
1024 <        }
1025 <    }
1026 <
1027 <    public void testThenCombine_exceptionalCompletion3() {
1028 <        for (ExecutionMode m : ExecutionMode.values())
1029 <        for (Integer v1 : new Integer[] { 1, null }) {
1030 <
1031 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1032 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1033 <        final SubtractFunction r = new SubtractFunction();
1034 <        final CFException ex = new CFException();
1035 <
1036 <        g.completeExceptionally(ex);
1037 <        f.complete(v1);
1285 >        (fFirst ? f : g).complete(v1);
1286 >        if (!createIncomplete)
1287 >            (!fFirst ? f : g).completeExceptionally(ex);
1288          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1289 <
1290 <        checkCompletedWithWrappedCFException(h, ex);
1291 <        checkCompletedWithWrappedCFException(g, ex);
1042 <        assertEquals(r.invocationCount, 0);
1043 <        checkCompletedNormally(f, v1);
1289 >        if (createIncomplete) {
1290 >            checkIncomplete(h);
1291 >            (!fFirst ? f : g).completeExceptionally(ex);
1292          }
1045    }
1046
1047    public void testThenCombine_exceptionalCompletion4() {
1048        for (ExecutionMode m : ExecutionMode.values())
1049        for (Integer v1 : new Integer[] { 1, null }) {
1050
1051        final CompletableFuture<Integer> f = new CompletableFuture<>();
1052        final CompletableFuture<Integer> g = new CompletableFuture<>();
1053        final SubtractFunction r = new SubtractFunction();
1054        final CFException ex = new CFException();
1055
1056        f.completeExceptionally(ex);
1057        g.complete(v1);
1058        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1293  
1294          checkCompletedWithWrappedCFException(h, ex);
1295 <        checkCompletedWithWrappedCFException(f, ex);
1296 <        assertEquals(r.invocationCount, 0);
1297 <        checkCompletedNormally(g, v1);
1298 <        }
1065 <    }
1295 >        assertEquals(0, r.invocationCount);
1296 >        checkCompletedNormally(fFirst ? f : g, v1);
1297 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1298 >    }}
1299  
1300      /**
1301       * thenCombine result completes exceptionally if action does
1302       */
1303 <    public void testThenCombine_actionFailed1() {
1303 >    public void testThenCombine_actionFailed() {
1304          for (ExecutionMode m : ExecutionMode.values())
1305 +        for (boolean fFirst : new boolean[] { true, false })
1306          for (Integer v1 : new Integer[] { 1, null })
1307 <        for (Integer v2 : new Integer[] { 2, null }) {
1308 <
1307 >        for (Integer v2 : new Integer[] { 2, null })
1308 >    {
1309          final CompletableFuture<Integer> f = new CompletableFuture<>();
1310          final CompletableFuture<Integer> g = new CompletableFuture<>();
1311          final FailingBiFunction r = new FailingBiFunction();
1312          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1313  
1314 <        f.complete(v1);
1315 <        checkIncomplete(h);
1316 <        g.complete(v2);
1317 <
1318 <        checkCompletedWithWrappedCFException(h);
1319 <        checkCompletedNormally(f, v1);
1086 <        checkCompletedNormally(g, v2);
1314 >        if (fFirst) {
1315 >            f.complete(v1);
1316 >            g.complete(v2);
1317 >        } else {
1318 >            g.complete(v2);
1319 >            f.complete(v1);
1320          }
1088    }
1089
1090    public void testThenCombine_actionFailed2() {
1091        for (ExecutionMode m : ExecutionMode.values())
1092        for (Integer v1 : new Integer[] { 1, null })
1093        for (Integer v2 : new Integer[] { 2, null }) {
1094
1095        final CompletableFuture<Integer> f = new CompletableFuture<>();
1096        final CompletableFuture<Integer> g = new CompletableFuture<>();
1097        final FailingBiFunction r = new FailingBiFunction();
1098        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1099
1100        g.complete(v2);
1101        checkIncomplete(h);
1102        f.complete(v1);
1321  
1322          checkCompletedWithWrappedCFException(h);
1323          checkCompletedNormally(f, v1);
1324          checkCompletedNormally(g, v2);
1325 <        }
1108 <    }
1325 >    }}
1326  
1327      /**
1328       * thenCombine result completes exceptionally if either source cancelled
1329       */
1330 <    public void testThenCombine_sourceCancelled1() {
1330 >    public void testThenCombine_sourceCancelled() {
1331          for (ExecutionMode m : ExecutionMode.values())
1332          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1333 <        for (Integer v1 : new Integer[] { 1, null }) {
1334 <
1333 >        for (boolean createIncomplete : new boolean[] { true, false })
1334 >        for (boolean fFirst : new boolean[] { true, false })
1335 >        for (Integer v1 : new Integer[] { 1, null })
1336 >    {
1337          final CompletableFuture<Integer> f = new CompletableFuture<>();
1338          final CompletableFuture<Integer> g = new CompletableFuture<>();
1339          final SubtractFunction r = new SubtractFunction();
1121        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1340  
1341 <        assertTrue(f.cancel(mayInterruptIfRunning));
1342 <        checkIncomplete(h);
1343 <        g.complete(v1);
1126 <
1127 <        checkCompletedWithWrappedCancellationException(h);
1128 <        checkCancelled(f);
1129 <        assertEquals(r.invocationCount, 0);
1130 <        checkCompletedNormally(g, v1);
1131 <        }
1132 <    }
1133 <
1134 <    public void testThenCombine_sourceCancelled2() {
1135 <        for (ExecutionMode m : ExecutionMode.values())
1136 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1137 <        for (Integer v1 : new Integer[] { 1, null }) {
1138 <
1139 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1140 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1141 <        final SubtractFunction r = new SubtractFunction();
1341 >        (fFirst ? f : g).complete(v1);
1342 >        if (!createIncomplete)
1343 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1344          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1345 <
1346 <        assertTrue(g.cancel(mayInterruptIfRunning));
1347 <        checkIncomplete(h);
1146 <        f.complete(v1);
1147 <
1148 <        checkCompletedWithWrappedCancellationException(h);
1149 <        checkCancelled(g);
1150 <        assertEquals(r.invocationCount, 0);
1151 <        checkCompletedNormally(f, v1);
1345 >        if (createIncomplete) {
1346 >            checkIncomplete(h);
1347 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1348          }
1153    }
1154
1155    public void testThenCombine_sourceCancelled3() {
1156        for (ExecutionMode m : ExecutionMode.values())
1157        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1158        for (Integer v1 : new Integer[] { 1, null }) {
1159
1160        final CompletableFuture<Integer> f = new CompletableFuture<>();
1161        final CompletableFuture<Integer> g = new CompletableFuture<>();
1162        final SubtractFunction r = new SubtractFunction();
1163
1164        assertTrue(g.cancel(mayInterruptIfRunning));
1165        f.complete(v1);
1166        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1349  
1350          checkCompletedWithWrappedCancellationException(h);
1351 <        checkCancelled(g);
1352 <        assertEquals(r.invocationCount, 0);
1353 <        checkCompletedNormally(f, v1);
1354 <        }
1173 <    }
1174 <
1175 <    public void testThenCombine_sourceCancelled4() {
1176 <        for (ExecutionMode m : ExecutionMode.values())
1177 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1178 <        for (Integer v1 : new Integer[] { 1, null }) {
1179 <
1180 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1181 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1182 <        final SubtractFunction r = new SubtractFunction();
1183 <
1184 <        assertTrue(f.cancel(mayInterruptIfRunning));
1185 <        g.complete(v1);
1186 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1187 <
1188 <        checkCompletedWithWrappedCancellationException(h);
1189 <        checkCancelled(f);
1190 <        assertEquals(r.invocationCount, 0);
1191 <        checkCompletedNormally(g, v1);
1192 <        }
1193 <    }
1351 >        checkCancelled(!fFirst ? f : g);
1352 >        assertEquals(0, r.invocationCount);
1353 >        checkCompletedNormally(fFirst ? f : g, v1);
1354 >    }}
1355  
1356      /**
1357       * thenAcceptBoth result completes normally after normal
1358       * completion of sources
1359       */
1360 <    public void testThenAcceptBoth_normalCompletion1() {
1360 >    public void testThenAcceptBoth_normalCompletion() {
1361          for (ExecutionMode m : ExecutionMode.values())
1362 +        for (boolean createIncomplete : new boolean[] { true, false })
1363 +        for (boolean fFirst : new boolean[] { true, false })
1364          for (Integer v1 : new Integer[] { 1, null })
1365 <        for (Integer v2 : new Integer[] { 2, null }) {
1366 <
1365 >        for (Integer v2 : new Integer[] { 2, null })
1366 >    {
1367          final CompletableFuture<Integer> f = new CompletableFuture<>();
1368          final CompletableFuture<Integer> g = new CompletableFuture<>();
1369          final SubtractAction r = new SubtractAction();
1207        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1370  
1371 <        f.complete(v1);
1372 <        checkIncomplete(h);
1373 <        assertFalse(r.ran());
1212 <        g.complete(v2);
1213 <
1214 <        checkCompletedNormally(h, null);
1215 <        assertEquals(r.value, subtract(v1, v2));
1216 <        checkCompletedNormally(f, v1);
1217 <        checkCompletedNormally(g, v2);
1218 <        }
1219 <    }
1220 <
1221 <    public void testThenAcceptBoth_normalCompletion2() {
1222 <        for (ExecutionMode m : ExecutionMode.values())
1223 <        for (Integer v1 : new Integer[] { 1, null })
1224 <        for (Integer v2 : new Integer[] { 2, null }) {
1225 <
1226 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1227 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1228 <        final SubtractAction r = new SubtractAction();
1371 >        if (fFirst) f.complete(v1); else g.complete(v2);
1372 >        if (!createIncomplete)
1373 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1374          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1375 <
1376 <        g.complete(v2);
1377 <        checkIncomplete(h);
1378 <        assertFalse(r.ran());
1234 <        f.complete(v1);
1235 <
1236 <        checkCompletedNormally(h, null);
1237 <        assertEquals(r.value, subtract(v1, v2));
1238 <        checkCompletedNormally(f, v1);
1239 <        checkCompletedNormally(g, v2);
1375 >        if (createIncomplete) {
1376 >            checkIncomplete(h);
1377 >            assertEquals(0, r.invocationCount);
1378 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1379          }
1241    }
1242
1243    public void testThenAcceptBoth_normalCompletion3() {
1244        for (ExecutionMode m : ExecutionMode.values())
1245        for (Integer v1 : new Integer[] { 1, null })
1246        for (Integer v2 : new Integer[] { 2, null }) {
1247
1248        final CompletableFuture<Integer> f = new CompletableFuture<>();
1249        final CompletableFuture<Integer> g = new CompletableFuture<>();
1250        final SubtractAction r = new SubtractAction();
1251
1252        g.complete(v2);
1253        f.complete(v1);
1254        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1255
1256        checkCompletedNormally(h, null);
1257        assertEquals(r.value, subtract(v1, v2));
1258        checkCompletedNormally(f, v1);
1259        checkCompletedNormally(g, v2);
1260        }
1261    }
1262
1263    public void testThenAcceptBoth_normalCompletion4() {
1264        for (ExecutionMode m : ExecutionMode.values())
1265        for (Integer v1 : new Integer[] { 1, null })
1266        for (Integer v2 : new Integer[] { 2, null }) {
1267
1268        final CompletableFuture<Integer> f = new CompletableFuture<>();
1269        final CompletableFuture<Integer> g = new CompletableFuture<>();
1270        final SubtractAction r = new SubtractAction();
1271
1272        f.complete(v1);
1273        g.complete(v2);
1274        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1380  
1381          checkCompletedNormally(h, null);
1382 <        assertEquals(r.value, subtract(v1, v2));
1382 >        assertEquals(subtract(v1, v2), r.value);
1383          checkCompletedNormally(f, v1);
1384          checkCompletedNormally(g, v2);
1385 <        }
1281 <    }
1385 >    }}
1386  
1387      /**
1388       * thenAcceptBoth result completes exceptionally after exceptional
1389       * completion of either source
1390       */
1391 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1391 >    public void testThenAcceptBoth_exceptionalCompletion() {
1392          for (ExecutionMode m : ExecutionMode.values())
1393 <        for (Integer v1 : new Integer[] { 1, null }) {
1394 <
1393 >        for (boolean createIncomplete : new boolean[] { true, false })
1394 >        for (boolean fFirst : new boolean[] { true, false })
1395 >        for (Integer v1 : new Integer[] { 1, null })
1396 >    {
1397          final CompletableFuture<Integer> f = new CompletableFuture<>();
1398          final CompletableFuture<Integer> g = new CompletableFuture<>();
1293        final SubtractAction r = new SubtractAction();
1294        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1399          final CFException ex = new CFException();
1296
1297        f.completeExceptionally(ex);
1298        checkIncomplete(h);
1299        g.complete(v1);
1300
1301        checkCompletedWithWrappedCFException(h, ex);
1302        checkCompletedWithWrappedCFException(f, ex);
1303        assertEquals(r.invocationCount, 0);
1304        checkCompletedNormally(g, v1);
1305        }
1306    }
1307
1308    public void testThenAcceptBoth_exceptionalCompletion2() {
1309        for (ExecutionMode m : ExecutionMode.values())
1310        for (Integer v1 : new Integer[] { 1, null }) {
1311
1312        final CompletableFuture<Integer> f = new CompletableFuture<>();
1313        final CompletableFuture<Integer> g = new CompletableFuture<>();
1400          final SubtractAction r = new SubtractAction();
1315        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1316        final CFException ex = new CFException();
1401  
1402 <        g.completeExceptionally(ex);
1403 <        checkIncomplete(h);
1404 <        f.complete(v1);
1321 <
1322 <        checkCompletedWithWrappedCFException(h, ex);
1323 <        checkCompletedWithWrappedCFException(g, ex);
1324 <        assertEquals(r.invocationCount, 0);
1325 <        checkCompletedNormally(f, v1);
1326 <        }
1327 <    }
1328 <
1329 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1330 <        for (ExecutionMode m : ExecutionMode.values())
1331 <        for (Integer v1 : new Integer[] { 1, null }) {
1332 <
1333 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1334 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1335 <        final SubtractAction r = new SubtractAction();
1336 <        final CFException ex = new CFException();
1337 <
1338 <        g.completeExceptionally(ex);
1339 <        f.complete(v1);
1402 >        (fFirst ? f : g).complete(v1);
1403 >        if (!createIncomplete)
1404 >            (!fFirst ? f : g).completeExceptionally(ex);
1405          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1406 <
1407 <        checkCompletedWithWrappedCFException(h, ex);
1408 <        checkCompletedWithWrappedCFException(g, ex);
1344 <        assertEquals(r.invocationCount, 0);
1345 <        checkCompletedNormally(f, v1);
1406 >        if (createIncomplete) {
1407 >            checkIncomplete(h);
1408 >            (!fFirst ? f : g).completeExceptionally(ex);
1409          }
1347    }
1348
1349    public void testThenAcceptBoth_exceptionalCompletion4() {
1350        for (ExecutionMode m : ExecutionMode.values())
1351        for (Integer v1 : new Integer[] { 1, null }) {
1352
1353        final CompletableFuture<Integer> f = new CompletableFuture<>();
1354        final CompletableFuture<Integer> g = new CompletableFuture<>();
1355        final SubtractAction r = new SubtractAction();
1356        final CFException ex = new CFException();
1357
1358        f.completeExceptionally(ex);
1359        g.complete(v1);
1360        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1410  
1411          checkCompletedWithWrappedCFException(h, ex);
1412 <        checkCompletedWithWrappedCFException(f, ex);
1413 <        assertFalse(r.ran());
1414 <        checkCompletedNormally(g, v1);
1415 <        }
1367 <    }
1412 >        assertEquals(0, r.invocationCount);
1413 >        checkCompletedNormally(fFirst ? f : g, v1);
1414 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1415 >    }}
1416  
1417      /**
1418       * thenAcceptBoth result completes exceptionally if action does
1419       */
1420 <    public void testThenAcceptBoth_actionFailed1() {
1420 >    public void testThenAcceptBoth_actionFailed() {
1421          for (ExecutionMode m : ExecutionMode.values())
1422 +        for (boolean fFirst : new boolean[] { true, false })
1423          for (Integer v1 : new Integer[] { 1, null })
1424 <        for (Integer v2 : new Integer[] { 2, null }) {
1425 <
1424 >        for (Integer v2 : new Integer[] { 2, null })
1425 >    {
1426          final CompletableFuture<Integer> f = new CompletableFuture<>();
1427          final CompletableFuture<Integer> g = new CompletableFuture<>();
1428          final FailingBiConsumer r = new FailingBiConsumer();
1429          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1430  
1431 <        f.complete(v1);
1432 <        checkIncomplete(h);
1433 <        g.complete(v2);
1434 <
1435 <        checkCompletedWithWrappedCFException(h);
1436 <        checkCompletedNormally(f, v1);
1388 <        checkCompletedNormally(g, v2);
1431 >        if (fFirst) {
1432 >            f.complete(v1);
1433 >            g.complete(v2);
1434 >        } else {
1435 >            g.complete(v2);
1436 >            f.complete(v1);
1437          }
1390    }
1391
1392    public void testThenAcceptBoth_actionFailed2() {
1393        for (ExecutionMode m : ExecutionMode.values())
1394        for (Integer v1 : new Integer[] { 1, null })
1395        for (Integer v2 : new Integer[] { 2, null }) {
1396
1397        final CompletableFuture<Integer> f = new CompletableFuture<>();
1398        final CompletableFuture<Integer> g = new CompletableFuture<>();
1399        final FailingBiConsumer r = new FailingBiConsumer();
1400        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1401
1402        g.complete(v2);
1403        checkIncomplete(h);
1404        f.complete(v1);
1438  
1439          checkCompletedWithWrappedCFException(h);
1440          checkCompletedNormally(f, v1);
1441          checkCompletedNormally(g, v2);
1442 <        }
1410 <    }
1442 >    }}
1443  
1444      /**
1445       * thenAcceptBoth result completes exceptionally if either source cancelled
1446       */
1447 <    public void testThenAcceptBoth_sourceCancelled1() {
1416 <        for (ExecutionMode m : ExecutionMode.values())
1417 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1418 <        for (Integer v1 : new Integer[] { 1, null }) {
1419 <
1420 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1421 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1422 <        final SubtractAction r = new SubtractAction();
1423 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1424 <
1425 <        assertTrue(f.cancel(mayInterruptIfRunning));
1426 <        checkIncomplete(h);
1427 <        g.complete(v1);
1428 <
1429 <        checkCompletedWithWrappedCancellationException(h);
1430 <        checkCancelled(f);
1431 <        assertEquals(r.invocationCount, 0);
1432 <        checkCompletedNormally(g, v1);
1433 <        }
1434 <    }
1435 <
1436 <    public void testThenAcceptBoth_sourceCancelled2() {
1447 >    public void testThenAcceptBoth_sourceCancelled() {
1448          for (ExecutionMode m : ExecutionMode.values())
1449          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1450 <        for (Integer v1 : new Integer[] { 1, null }) {
1451 <
1452 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1453 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1443 <        final SubtractAction r = new SubtractAction();
1444 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1445 <
1446 <        assertTrue(g.cancel(mayInterruptIfRunning));
1447 <        checkIncomplete(h);
1448 <        f.complete(v1);
1449 <
1450 <        checkCompletedWithWrappedCancellationException(h);
1451 <        checkCancelled(g);
1452 <        assertEquals(r.invocationCount, 0);
1453 <        checkCompletedNormally(f, v1);
1454 <        }
1455 <    }
1456 <
1457 <    public void testThenAcceptBoth_sourceCancelled3() {
1458 <        for (ExecutionMode m : ExecutionMode.values())
1459 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1460 <        for (Integer v1 : new Integer[] { 1, null }) {
1461 <
1450 >        for (boolean createIncomplete : new boolean[] { true, false })
1451 >        for (boolean fFirst : new boolean[] { true, false })
1452 >        for (Integer v1 : new Integer[] { 1, null })
1453 >    {
1454          final CompletableFuture<Integer> f = new CompletableFuture<>();
1455          final CompletableFuture<Integer> g = new CompletableFuture<>();
1456          final SubtractAction r = new SubtractAction();
1457  
1458 <        assertTrue(g.cancel(mayInterruptIfRunning));
1459 <        f.complete(v1);
1458 >        (fFirst ? f : g).complete(v1);
1459 >        if (!createIncomplete)
1460 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1461          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1462 <
1463 <        checkCompletedWithWrappedCancellationException(h);
1464 <        checkCancelled(g);
1472 <        assertEquals(r.invocationCount, 0);
1473 <        checkCompletedNormally(f, v1);
1462 >        if (createIncomplete) {
1463 >            checkIncomplete(h);
1464 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1465          }
1475    }
1476
1477    public void testThenAcceptBoth_sourceCancelled4() {
1478        for (ExecutionMode m : ExecutionMode.values())
1479        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1480        for (Integer v1 : new Integer[] { 1, null }) {
1481
1482        final CompletableFuture<Integer> f = new CompletableFuture<>();
1483        final CompletableFuture<Integer> g = new CompletableFuture<>();
1484        final SubtractAction r = new SubtractAction();
1485
1486        assertTrue(f.cancel(mayInterruptIfRunning));
1487        g.complete(v1);
1488        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1466  
1467          checkCompletedWithWrappedCancellationException(h);
1468 <        checkCancelled(f);
1469 <        assertEquals(r.invocationCount, 0);
1470 <        checkCompletedNormally(g, v1);
1471 <        }
1495 <    }
1468 >        checkCancelled(!fFirst ? f : g);
1469 >        assertEquals(0, r.invocationCount);
1470 >        checkCompletedNormally(fFirst ? f : g, v1);
1471 >    }}
1472  
1473      /**
1474       * runAfterBoth result completes normally after normal
1475       * completion of sources
1476       */
1477 <    public void testRunAfterBoth_normalCompletion1() {
1477 >    public void testRunAfterBoth_normalCompletion() {
1478          for (ExecutionMode m : ExecutionMode.values())
1479 +        for (boolean createIncomplete : new boolean[] { true, false })
1480 +        for (boolean fFirst : new boolean[] { true, false })
1481          for (Integer v1 : new Integer[] { 1, null })
1482 <        for (Integer v2 : new Integer[] { 2, null }) {
1483 <
1482 >        for (Integer v2 : new Integer[] { 2, null })
1483 >    {
1484          final CompletableFuture<Integer> f = new CompletableFuture<>();
1485          final CompletableFuture<Integer> g = new CompletableFuture<>();
1486          final Noop r = new Noop();
1509        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1510
1511        f.complete(v1);
1512        checkIncomplete(h);
1513        assertFalse(r.ran);
1514        g.complete(v2);
1515
1516        checkCompletedNormally(h, null);
1517        assertEquals(r.invocationCount, 1);
1518        checkCompletedNormally(f, v1);
1519        checkCompletedNormally(g, v2);
1520        }
1521    }
1522
1523    public void testRunAfterBoth_normalCompletion2() {
1524        for (ExecutionMode m : ExecutionMode.values())
1525        for (Integer v1 : new Integer[] { 1, null })
1526        for (Integer v2 : new Integer[] { 2, null }) {
1487  
1488 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1489 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1490 <        final Noop r = new Noop();
1488 >        if (fFirst) f.complete(v1); else g.complete(v2);
1489 >        if (!createIncomplete)
1490 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1491          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1492 <
1493 <        g.complete(v2);
1494 <        checkIncomplete(h);
1495 <        assertFalse(r.ran);
1536 <        f.complete(v1);
1537 <
1538 <        checkCompletedNormally(h, null);
1539 <        assertEquals(r.invocationCount, 1);
1540 <        checkCompletedNormally(f, v1);
1541 <        checkCompletedNormally(g, v2);
1492 >        if (createIncomplete) {
1493 >            checkIncomplete(h);
1494 >            assertEquals(0, r.invocationCount);
1495 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1496          }
1543    }
1544
1545    public void testRunAfterBoth_normalCompletion3() {
1546        for (ExecutionMode m : ExecutionMode.values())
1547        for (Integer v1 : new Integer[] { 1, null })
1548        for (Integer v2 : new Integer[] { 2, null }) {
1549
1550        final CompletableFuture<Integer> f = new CompletableFuture<>();
1551        final CompletableFuture<Integer> g = new CompletableFuture<>();
1552        final Noop r = new Noop();
1553
1554        g.complete(v2);
1555        f.complete(v1);
1556        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1497  
1498          checkCompletedNormally(h, null);
1499 <        assertTrue(r.ran);
1499 >        assertEquals(1, r.invocationCount);
1500          checkCompletedNormally(f, v1);
1501          checkCompletedNormally(g, v2);
1502 <        }
1563 <    }
1564 <
1565 <    public void testRunAfterBoth_normalCompletion4() {
1566 <        for (ExecutionMode m : ExecutionMode.values())
1567 <        for (Integer v1 : new Integer[] { 1, null })
1568 <        for (Integer v2 : new Integer[] { 2, null }) {
1569 <
1570 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1571 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1572 <        final Noop r = new Noop();
1573 <
1574 <        f.complete(v1);
1575 <        g.complete(v2);
1576 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1577 <
1578 <        checkCompletedNormally(h, null);
1579 <        assertEquals(r.invocationCount, 1);
1580 <        checkCompletedNormally(f, v1);
1581 <        checkCompletedNormally(g, v2);
1582 <        }
1583 <    }
1502 >    }}
1503  
1504      /**
1505       * runAfterBoth result completes exceptionally after exceptional
1506       * completion of either source
1507       */
1508 <    public void testRunAfterBoth_exceptionalCompletion1() {
1508 >    public void testRunAfterBoth_exceptionalCompletion() {
1509          for (ExecutionMode m : ExecutionMode.values())
1510 <        for (Integer v1 : new Integer[] { 1, null }) {
1511 <
1510 >        for (boolean createIncomplete : new boolean[] { true, false })
1511 >        for (boolean fFirst : new boolean[] { true, false })
1512 >        for (Integer v1 : new Integer[] { 1, null })
1513 >    {
1514          final CompletableFuture<Integer> f = new CompletableFuture<>();
1515          final CompletableFuture<Integer> g = new CompletableFuture<>();
1595        final Noop r = new Noop();
1596        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1516          final CFException ex = new CFException();
1598
1599        f.completeExceptionally(ex);
1600        checkIncomplete(h);
1601        g.complete(v1);
1602
1603        checkCompletedWithWrappedCFException(h, ex);
1604        checkCompletedWithWrappedCFException(f, ex);
1605        assertEquals(r.invocationCount, 0);
1606        checkCompletedNormally(g, v1);
1607        }
1608    }
1609
1610    public void testRunAfterBoth_exceptionalCompletion2() {
1611        for (ExecutionMode m : ExecutionMode.values())
1612        for (Integer v1 : new Integer[] { 1, null }) {
1613
1614        final CompletableFuture<Integer> f = new CompletableFuture<>();
1615        final CompletableFuture<Integer> g = new CompletableFuture<>();
1517          final Noop r = new Noop();
1617        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1618        final CFException ex = new CFException();
1619
1620        g.completeExceptionally(ex);
1621        checkIncomplete(h);
1622        f.complete(v1);
1623
1624        checkCompletedWithWrappedCFException(h, ex);
1625        checkCompletedWithWrappedCFException(g, ex);
1626        assertEquals(r.invocationCount, 0);
1627        checkCompletedNormally(f, v1);
1628        }
1629    }
1518  
1519 <    public void testRunAfterBoth_exceptionalCompletion3() {
1520 <        for (ExecutionMode m : ExecutionMode.values())
1521 <        for (Integer v1 : new Integer[] { 1, null }) {
1634 <
1635 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1636 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1637 <        final Noop r = new Noop();
1638 <        final CFException ex = new CFException();
1639 <
1640 <        g.completeExceptionally(ex);
1641 <        f.complete(v1);
1519 >        (fFirst ? f : g).complete(v1);
1520 >        if (!createIncomplete)
1521 >            (!fFirst ? f : g).completeExceptionally(ex);
1522          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1523 <
1524 <        checkCompletedWithWrappedCFException(h, ex);
1525 <        checkCompletedWithWrappedCFException(g, ex);
1646 <        assertEquals(r.invocationCount, 0);
1647 <        checkCompletedNormally(f, v1);
1523 >        if (createIncomplete) {
1524 >            checkIncomplete(h);
1525 >            (!fFirst ? f : g).completeExceptionally(ex);
1526          }
1649    }
1650
1651    public void testRunAfterBoth_exceptionalCompletion4() {
1652        for (ExecutionMode m : ExecutionMode.values())
1653        for (Integer v1 : new Integer[] { 1, null }) {
1654
1655        final CompletableFuture<Integer> f = new CompletableFuture<>();
1656        final CompletableFuture<Integer> g = new CompletableFuture<>();
1657        final Noop r = new Noop();
1658        final CFException ex = new CFException();
1659
1660        f.completeExceptionally(ex);
1661        g.complete(v1);
1662        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1527  
1528          checkCompletedWithWrappedCFException(h, ex);
1529 <        checkCompletedWithWrappedCFException(f, ex);
1530 <        assertEquals(r.invocationCount, 0);
1531 <        checkCompletedNormally(g, v1);
1532 <        }
1669 <    }
1529 >        assertEquals(0, r.invocationCount);
1530 >        checkCompletedNormally(fFirst ? f : g, v1);
1531 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1532 >    }}
1533  
1534      /**
1535       * runAfterBoth result completes exceptionally if action does
1536       */
1537 <    public void testRunAfterBoth_actionFailed1() {
1537 >    public void testRunAfterBoth_actionFailed() {
1538          for (ExecutionMode m : ExecutionMode.values())
1539 +        for (boolean fFirst : new boolean[] { true, false })
1540          for (Integer v1 : new Integer[] { 1, null })
1541 <        for (Integer v2 : new Integer[] { 2, null }) {
1542 <
1541 >        for (Integer v2 : new Integer[] { 2, null })
1542 >    {
1543          final CompletableFuture<Integer> f = new CompletableFuture<>();
1544          final CompletableFuture<Integer> g = new CompletableFuture<>();
1545 <        final FailingNoop r = new FailingNoop();
1682 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1545 >        final FailingRunnable r = new FailingRunnable();
1546  
1547 <        f.complete(v1);
1548 <        checkIncomplete(h);
1549 <        g.complete(v2);
1550 <
1551 <        checkCompletedWithWrappedCFException(h);
1552 <        checkCompletedNormally(f, v1);
1553 <        checkCompletedNormally(g, v2);
1547 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1548 >        if (fFirst) {
1549 >            f.complete(v1);
1550 >            g.complete(v2);
1551 >        } else {
1552 >            g.complete(v2);
1553 >            f.complete(v1);
1554          }
1555 <    }
1555 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1556  
1557 <    public void testRunAfterBoth_actionFailed2() {
1558 <        for (ExecutionMode m : ExecutionMode.values())
1696 <        for (Integer v1 : new Integer[] { 1, null })
1697 <        for (Integer v2 : new Integer[] { 2, null }) {
1698 <
1699 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1700 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1701 <        final FailingNoop r = new FailingNoop();
1702 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1703 <
1704 <        g.complete(v2);
1705 <        checkIncomplete(h);
1706 <        f.complete(v1);
1707 <
1708 <        checkCompletedWithWrappedCFException(h);
1557 >        checkCompletedWithWrappedCFException(h1);
1558 >        checkCompletedWithWrappedCFException(h2);
1559          checkCompletedNormally(f, v1);
1560          checkCompletedNormally(g, v2);
1561 <        }
1712 <    }
1561 >    }}
1562  
1563      /**
1564       * runAfterBoth result completes exceptionally if either source cancelled
1565       */
1566 <    public void testRunAfterBoth_sourceCancelled1() {
1718 <        for (ExecutionMode m : ExecutionMode.values())
1719 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1720 <        for (Integer v1 : new Integer[] { 1, null }) {
1721 <
1722 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1723 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1724 <        final Noop r = new Noop();
1725 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1726 <
1727 <        assertTrue(f.cancel(mayInterruptIfRunning));
1728 <        checkIncomplete(h);
1729 <        g.complete(v1);
1730 <
1731 <        checkCompletedWithWrappedCancellationException(h);
1732 <        checkCancelled(f);
1733 <        assertEquals(r.invocationCount, 0);
1734 <        checkCompletedNormally(g, v1);
1735 <        }
1736 <    }
1737 <
1738 <    public void testRunAfterBoth_sourceCancelled2() {
1566 >    public void testRunAfterBoth_sourceCancelled() {
1567          for (ExecutionMode m : ExecutionMode.values())
1568          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1569 <        for (Integer v1 : new Integer[] { 1, null }) {
1570 <
1569 >        for (boolean createIncomplete : new boolean[] { true, false })
1570 >        for (boolean fFirst : new boolean[] { true, false })
1571 >        for (Integer v1 : new Integer[] { 1, null })
1572 >    {
1573          final CompletableFuture<Integer> f = new CompletableFuture<>();
1574          final CompletableFuture<Integer> g = new CompletableFuture<>();
1575          final Noop r = new Noop();
1746        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1747
1748        assertTrue(g.cancel(mayInterruptIfRunning));
1749        checkIncomplete(h);
1750        f.complete(v1);
1751
1752        checkCompletedWithWrappedCancellationException(h);
1753        checkCancelled(g);
1754        assertEquals(r.invocationCount, 0);
1755        checkCompletedNormally(f, v1);
1756        }
1757    }
1576  
1759    public void testRunAfterBoth_sourceCancelled3() {
1760        for (ExecutionMode m : ExecutionMode.values())
1761        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1762        for (Integer v1 : new Integer[] { 1, null }) {
1577  
1578 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1579 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1580 <        final Noop r = new Noop();
1767 <
1768 <        assertTrue(g.cancel(mayInterruptIfRunning));
1769 <        f.complete(v1);
1578 >        (fFirst ? f : g).complete(v1);
1579 >        if (!createIncomplete)
1580 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1581          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1582 <
1583 <        checkCompletedWithWrappedCancellationException(h);
1584 <        checkCancelled(g);
1774 <        assertEquals(r.invocationCount, 0);
1775 <        checkCompletedNormally(f, v1);
1582 >        if (createIncomplete) {
1583 >            checkIncomplete(h);
1584 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1585          }
1777    }
1778
1779    public void testRunAfterBoth_sourceCancelled4() {
1780        for (ExecutionMode m : ExecutionMode.values())
1781        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1782        for (Integer v1 : new Integer[] { 1, null }) {
1783
1784        final CompletableFuture<Integer> f = new CompletableFuture<>();
1785        final CompletableFuture<Integer> g = new CompletableFuture<>();
1786        final Noop r = new Noop();
1787
1788        assertTrue(f.cancel(mayInterruptIfRunning));
1789        g.complete(v1);
1790        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1586  
1587          checkCompletedWithWrappedCancellationException(h);
1588 <        checkCancelled(f);
1589 <        assertEquals(r.invocationCount, 0);
1590 <        checkCompletedNormally(g, v1);
1591 <        }
1797 <    }
1588 >        checkCancelled(!fFirst ? f : g);
1589 >        assertEquals(0, r.invocationCount);
1590 >        checkCompletedNormally(fFirst ? f : g, v1);
1591 >    }}
1592  
1593      /**
1594       * applyToEither result completes normally after normal completion
1595       * of either source
1596       */
1597 <    public void testApplyToEither_normalCompletion1() {
1597 >    public void testApplyToEither_normalCompletion() {
1598          for (ExecutionMode m : ExecutionMode.values())
1599 +        for (boolean createIncomplete : new boolean[] { true, false })
1600 +        for (boolean fFirst : new boolean[] { true, false })
1601          for (Integer v1 : new Integer[] { 1, null })
1602 <        for (Integer v2 : new Integer[] { 2, null }) {
1603 <
1602 >        for (Integer v2 : new Integer[] { 2, null })
1603 >    {
1604          final CompletableFuture<Integer> f = new CompletableFuture<>();
1605          final CompletableFuture<Integer> g = new CompletableFuture<>();
1606          final IncFunction r = new IncFunction();
1811        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1607  
1608 <        f.complete(v1);
1609 <        checkCompletedNormally(h, inc(v1));
1610 <        g.complete(v2);
1608 >        if (!createIncomplete)
1609 >            if (fFirst) f.complete(v1); else g.complete(v2);
1610 >        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1611 >        if (createIncomplete) {
1612 >            checkIncomplete(h);
1613 >            assertEquals(0, r.invocationCount);
1614 >            if (fFirst) f.complete(v1); else g.complete(v2);
1615 >        }
1616 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1617 >        if (!fFirst) f.complete(v1); else g.complete(v2);
1618  
1619          checkCompletedNormally(f, v1);
1620          checkCompletedNormally(g, v2);
1621 <        checkCompletedNormally(h, inc(v1));
1622 <        }
1821 <    }
1621 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1622 >    }}
1623  
1624 <    public void testApplyToEither_normalCompletion2() {
1624 >    public void testApplyToEither_normalCompletionBothAvailable() {
1625          for (ExecutionMode m : ExecutionMode.values())
1626 +        for (boolean fFirst : new boolean[] { true, false })
1627          for (Integer v1 : new Integer[] { 1, null })
1628 <        for (Integer v2 : new Integer[] { 2, null }) {
1629 <
1628 >        for (Integer v2 : new Integer[] { 2, null })
1629 >    {
1630          final CompletableFuture<Integer> f = new CompletableFuture<>();
1631          final CompletableFuture<Integer> g = new CompletableFuture<>();
1632          final IncFunction r = new IncFunction();
1831        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1832
1833        g.complete(v2);
1834        checkCompletedNormally(h, inc(v2));
1835        f.complete(v1);
1633  
1634 <        checkCompletedNormally(f, v1);
1635 <        checkCompletedNormally(g, v2);
1636 <        checkCompletedNormally(h, inc(v2));
1634 >        if (fFirst) {
1635 >            f.complete(v1);
1636 >            g.complete(v2);
1637 >        } else {
1638 >            g.complete(v2);
1639 >            f.complete(v1);
1640          }
1841    }
1842    public void testApplyToEither_normalCompletion3() {
1843        for (ExecutionMode m : ExecutionMode.values())
1844        for (Integer v1 : new Integer[] { 1, null })
1845        for (Integer v2 : new Integer[] { 2, null }) {
1846
1847        final CompletableFuture<Integer> f = new CompletableFuture<>();
1848        final CompletableFuture<Integer> g = new CompletableFuture<>();
1849        final IncFunction r = new IncFunction();
1641  
1851        f.complete(v1);
1852        g.complete(v2);
1642          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1643  
1644          checkCompletedNormally(f, v1);
# Line 1858 | Line 1647 | public class CompletableFutureTest exten
1647          // unspecified behavior
1648          assertTrue(Objects.equals(h.join(), inc(v1)) ||
1649                     Objects.equals(h.join(), inc(v2)));
1650 <        assertEquals(r.invocationCount, 1);
1651 <        }
1863 <    }
1650 >        assertEquals(1, r.invocationCount);
1651 >    }}
1652  
1653      /**
1654       * applyToEither result completes exceptionally after exceptional
# Line 1868 | Line 1656 | public class CompletableFutureTest exten
1656       */
1657      public void testApplyToEither_exceptionalCompletion1() {
1658          for (ExecutionMode m : ExecutionMode.values())
1659 <        for (Integer v1 : new Integer[] { 1, null }) {
1660 <
1659 >        for (boolean createIncomplete : new boolean[] { true, false })
1660 >        for (boolean fFirst : new boolean[] { true, false })
1661 >        for (Integer v1 : new Integer[] { 1, null })
1662 >    {
1663          final CompletableFuture<Integer> f = new CompletableFuture<>();
1664          final CompletableFuture<Integer> g = new CompletableFuture<>();
1665 +        final CFException ex = new CFException();
1666          final IncFunction r = new IncFunction();
1667 +
1668 +        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1669          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1670 <        final CFException ex = new CFException();
1670 >        if (createIncomplete) {
1671 >            checkIncomplete(h);
1672 >            assertEquals(0, r.invocationCount);
1673 >            (fFirst ? f : g).completeExceptionally(ex);
1674 >        }
1675  
1879        f.completeExceptionally(ex);
1676          checkCompletedWithWrappedCFException(h, ex);
1677 <        g.complete(v1);
1677 >        (!fFirst ? f : g).complete(v1);
1678  
1679 <        assertEquals(r.invocationCount, 0);
1680 <        checkCompletedNormally(g, v1);
1681 <        checkCompletedWithWrappedCFException(f, ex);
1679 >        assertEquals(0, r.invocationCount);
1680 >        checkCompletedNormally(!fFirst ? f : g, v1);
1681 >        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1682          checkCompletedWithWrappedCFException(h, ex);
1683 <        }
1888 <    }
1683 >    }}
1684  
1685      public void testApplyToEither_exceptionalCompletion2() {
1686          for (ExecutionMode m : ExecutionMode.values())
1687 <        for (Integer v1 : new Integer[] { 1, null }) {
1688 <
1687 >        for (boolean reverseArgs : new boolean[] { true, false })
1688 >        for (boolean fFirst : new boolean[] { true, false })
1689 >        for (Integer v1 : new Integer[] { 1, null })
1690 >    {
1691          final CompletableFuture<Integer> f = new CompletableFuture<>();
1692          final CompletableFuture<Integer> g = new CompletableFuture<>();
1693 <        final IncFunction r = new IncFunction();
1694 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1693 >        final IncFunction r1 = new IncFunction();
1694 >        final IncFunction r2 = new IncFunction();
1695          final CFException ex = new CFException();
1696 <
1697 <        g.completeExceptionally(ex);
1698 <        checkCompletedWithWrappedCFException(h, ex);
1699 <        f.complete(v1);
1700 <
1701 <        assertEquals(r.invocationCount, 0);
1702 <        checkCompletedNormally(f, v1);
1703 <        checkCompletedWithWrappedCFException(g, ex);
1704 <        checkCompletedWithWrappedCFException(h, ex);
1696 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1697 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1698 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1699 >        if (fFirst) {
1700 >            f.complete(v1);
1701 >            g.completeExceptionally(ex);
1702 >        } else {
1703 >            g.completeExceptionally(ex);
1704 >            f.complete(v1);
1705          }
1706 <    }
1910 <
1911 <    public void testApplyToEither_exceptionalCompletion3() {
1912 <        for (ExecutionMode m : ExecutionMode.values())
1913 <        for (Integer v1 : new Integer[] { 1, null }) {
1914 <
1915 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1916 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1917 <        final IncFunction r = new IncFunction();
1918 <        final CFException ex = new CFException();
1919 <
1920 <        g.completeExceptionally(ex);
1921 <        f.complete(v1);
1922 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1706 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1707  
1708          // unspecified behavior
1925        Integer v;
1709          try {
1710 <            assertEquals(h.join(), inc(v1));
1711 <            assertEquals(r.invocationCount, 1);
1710 >            assertEquals(inc(v1), h1.join());
1711 >            assertEquals(1, r1.invocationCount);
1712          } catch (CompletionException ok) {
1713 <            checkCompletedWithWrappedCFException(h, ex);
1714 <            assertEquals(r.invocationCount, 0);
1713 >            checkCompletedWithWrappedCFException(h1, ex);
1714 >            assertEquals(0, r1.invocationCount);
1715          }
1716  
1934        checkCompletedWithWrappedCFException(g, ex);
1935        checkCompletedNormally(f, v1);
1936        }
1937    }
1938
1939    public void testApplyToEither_exceptionalCompletion4() {
1940        for (ExecutionMode m : ExecutionMode.values())
1941        for (Integer v1 : new Integer[] { 1, null }) {
1942
1943        final CompletableFuture<Integer> f = new CompletableFuture<>();
1944        final CompletableFuture<Integer> g = new CompletableFuture<>();
1945        final IncFunction r = new IncFunction();
1946        final CFException ex = new CFException();
1947
1948        f.completeExceptionally(ex);
1949        g.complete(v1);
1950        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1951
1952        // unspecified behavior
1953        Integer v;
1717          try {
1718 <            assertEquals(h.join(), inc(v1));
1719 <            assertEquals(r.invocationCount, 1);
1718 >            assertEquals(inc(v1), h2.join());
1719 >            assertEquals(1, r2.invocationCount);
1720          } catch (CompletionException ok) {
1721 <            checkCompletedWithWrappedCFException(h, ex);
1722 <            assertEquals(r.invocationCount, 0);
1721 >            checkCompletedWithWrappedCFException(h2, ex);
1722 >            assertEquals(0, r2.invocationCount);
1723          }
1724  
1725 <        checkCompletedWithWrappedCFException(f, ex);
1726 <        checkCompletedNormally(g, v1);
1727 <        }
1965 <    }
1725 >        checkCompletedWithWrappedCFException(g, ex);
1726 >        checkCompletedNormally(f, v1);
1727 >    }}
1728  
1729      /**
1730       * applyToEither result completes exceptionally if action does
# Line 1970 | Line 1732 | public class CompletableFutureTest exten
1732      public void testApplyToEither_actionFailed1() {
1733          for (ExecutionMode m : ExecutionMode.values())
1734          for (Integer v1 : new Integer[] { 1, null })
1735 <        for (Integer v2 : new Integer[] { 2, null }) {
1736 <
1735 >        for (Integer v2 : new Integer[] { 2, null })
1736 >    {
1737          final CompletableFuture<Integer> f = new CompletableFuture<>();
1738          final CompletableFuture<Integer> g = new CompletableFuture<>();
1739          final FailingFunction r = new FailingFunction();
# Line 1982 | Line 1744 | public class CompletableFutureTest exten
1744          g.complete(v2);
1745          checkCompletedNormally(f, v1);
1746          checkCompletedNormally(g, v2);
1747 <        }
1986 <    }
1747 >    }}
1748  
1749      public void testApplyToEither_actionFailed2() {
1750          for (ExecutionMode m : ExecutionMode.values())
1751          for (Integer v1 : new Integer[] { 1, null })
1752 <        for (Integer v2 : new Integer[] { 2, null }) {
1753 <
1752 >        for (Integer v2 : new Integer[] { 2, null })
1753 >    {
1754          final CompletableFuture<Integer> f = new CompletableFuture<>();
1755          final CompletableFuture<Integer> g = new CompletableFuture<>();
1756          final FailingFunction r = new FailingFunction();
# Line 2000 | Line 1761 | public class CompletableFutureTest exten
1761          f.complete(v1);
1762          checkCompletedNormally(f, v1);
1763          checkCompletedNormally(g, v2);
1764 <        }
2004 <    }
1764 >    }}
1765  
1766      /**
1767       * applyToEither result completes exceptionally if either source cancelled
# Line 2009 | Line 1769 | public class CompletableFutureTest exten
1769      public void testApplyToEither_sourceCancelled1() {
1770          for (ExecutionMode m : ExecutionMode.values())
1771          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1772 <        for (Integer v1 : new Integer[] { 1, null }) {
1773 <
1772 >        for (boolean createIncomplete : new boolean[] { true, false })
1773 >        for (boolean fFirst : new boolean[] { true, false })
1774 >        for (Integer v1 : new Integer[] { 1, null })
1775 >    {
1776          final CompletableFuture<Integer> f = new CompletableFuture<>();
1777          final CompletableFuture<Integer> g = new CompletableFuture<>();
1778          final IncFunction r = new IncFunction();
1779 +
1780 +        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1781          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1782 +        if (createIncomplete) {
1783 +            checkIncomplete(h);
1784 +            assertEquals(0, r.invocationCount);
1785 +            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1786 +        }
1787  
2019        assertTrue(f.cancel(mayInterruptIfRunning));
1788          checkCompletedWithWrappedCancellationException(h);
1789 <        g.complete(v1);
1789 >        (!fFirst ? f : g).complete(v1);
1790  
1791 <        checkCancelled(f);
1792 <        assertEquals(r.invocationCount, 0);
1793 <        checkCompletedNormally(g, v1);
1791 >        assertEquals(0, r.invocationCount);
1792 >        checkCompletedNormally(!fFirst ? f : g, v1);
1793 >        checkCancelled(fFirst ? f : g);
1794          checkCompletedWithWrappedCancellationException(h);
1795 <        }
2028 <    }
1795 >    }}
1796  
1797      public void testApplyToEither_sourceCancelled2() {
1798          for (ExecutionMode m : ExecutionMode.values())
1799          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1800 <        for (Integer v1 : new Integer[] { 1, null }) {
1801 <
1800 >        for (boolean reverseArgs : new boolean[] { true, false })
1801 >        for (boolean fFirst : new boolean[] { true, false })
1802 >        for (Integer v1 : new Integer[] { 1, null })
1803 >    {
1804          final CompletableFuture<Integer> f = new CompletableFuture<>();
1805          final CompletableFuture<Integer> g = new CompletableFuture<>();
1806 <        final IncFunction r = new IncFunction();
1807 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1808 <
1809 <        assertTrue(g.cancel(mayInterruptIfRunning));
1810 <        checkCompletedWithWrappedCancellationException(h);
2042 <        f.complete(v1);
1806 >        final IncFunction r1 = new IncFunction();
1807 >        final IncFunction r2 = new IncFunction();
1808 >        final CFException ex = new CFException();
1809 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1810 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1811  
1812 <        checkCancelled(g);
1813 <        assertEquals(r.invocationCount, 0);
1814 <        checkCompletedNormally(f, v1);
1815 <        checkCompletedWithWrappedCancellationException(h);
1812 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1813 >        if (fFirst) {
1814 >            f.complete(v1);
1815 >            assertTrue(g.cancel(mayInterruptIfRunning));
1816 >        } else {
1817 >            assertTrue(g.cancel(mayInterruptIfRunning));
1818 >            f.complete(v1);
1819          }
1820 <    }
2050 <
2051 <    public void testApplyToEither_sourceCancelled3() {
2052 <        for (ExecutionMode m : ExecutionMode.values())
2053 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2054 <        for (Integer v1 : new Integer[] { 1, null }) {
2055 <
2056 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2057 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2058 <        final IncFunction r = new IncFunction();
2059 <
2060 <        assertTrue(g.cancel(mayInterruptIfRunning));
2061 <        f.complete(v1);
2062 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1820 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1821  
1822          // unspecified behavior
2065        Integer v;
1823          try {
1824 <            assertEquals(h.join(), inc(v1));
1825 <            assertEquals(r.invocationCount, 1);
1824 >            assertEquals(inc(v1), h1.join());
1825 >            assertEquals(1, r1.invocationCount);
1826          } catch (CompletionException ok) {
1827 <            checkCompletedWithWrappedCancellationException(h);
1828 <            assertEquals(r.invocationCount, 0);
1827 >            checkCompletedWithWrappedCancellationException(h1);
1828 >            assertEquals(0, r1.invocationCount);
1829          }
1830  
2074        checkCancelled(g);
2075        checkCompletedNormally(f, v1);
2076        }
2077    }
2078
2079    public void testApplyToEither_sourceCancelled4() {
2080        for (ExecutionMode m : ExecutionMode.values())
2081        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2082        for (Integer v1 : new Integer[] { 1, null }) {
2083
2084        final CompletableFuture<Integer> f = new CompletableFuture<>();
2085        final CompletableFuture<Integer> g = new CompletableFuture<>();
2086        final IncFunction r = new IncFunction();
2087
2088        assertTrue(f.cancel(mayInterruptIfRunning));
2089        g.complete(v1);
2090        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2091
2092        // unspecified behavior
2093        Integer v;
1831          try {
1832 <            assertEquals(h.join(), inc(v1));
1833 <            assertEquals(r.invocationCount, 1);
1832 >            assertEquals(inc(v1), h2.join());
1833 >            assertEquals(1, r2.invocationCount);
1834          } catch (CompletionException ok) {
1835 <            checkCompletedWithWrappedCancellationException(h);
1836 <            assertEquals(r.invocationCount, 0);
1835 >            checkCompletedWithWrappedCancellationException(h2);
1836 >            assertEquals(0, r2.invocationCount);
1837          }
1838  
1839 <        checkCancelled(f);
1840 <        checkCompletedNormally(g, v1);
1841 <        }
2105 <    }
1839 >        checkCancelled(g);
1840 >        checkCompletedNormally(f, v1);
1841 >    }}
1842  
1843      /**
1844       * acceptEither result completes normally after normal completion
# Line 2111 | Line 1847 | public class CompletableFutureTest exten
1847      public void testAcceptEither_normalCompletion1() {
1848          for (ExecutionMode m : ExecutionMode.values())
1849          for (Integer v1 : new Integer[] { 1, null })
1850 <        for (Integer v2 : new Integer[] { 2, null }) {
1851 <
1850 >        for (Integer v2 : new Integer[] { 2, null })
1851 >    {
1852          final CompletableFuture<Integer> f = new CompletableFuture<>();
1853          final CompletableFuture<Integer> g = new CompletableFuture<>();
1854          final IncAction r = new IncAction();
# Line 2120 | Line 1856 | public class CompletableFutureTest exten
1856  
1857          f.complete(v1);
1858          checkCompletedNormally(h, null);
1859 <        assertEquals(r.value, inc(v1));
1859 >        assertEquals(inc(v1), r.value);
1860          g.complete(v2);
1861  
1862          checkCompletedNormally(f, v1);
1863          checkCompletedNormally(g, v2);
1864          checkCompletedNormally(h, null);
1865 <        }
2130 <    }
1865 >    }}
1866  
1867      public void testAcceptEither_normalCompletion2() {
1868          for (ExecutionMode m : ExecutionMode.values())
1869          for (Integer v1 : new Integer[] { 1, null })
1870 <        for (Integer v2 : new Integer[] { 2, null }) {
1871 <
1870 >        for (Integer v2 : new Integer[] { 2, null })
1871 >    {
1872          final CompletableFuture<Integer> f = new CompletableFuture<>();
1873          final CompletableFuture<Integer> g = new CompletableFuture<>();
1874          final IncAction r = new IncAction();
# Line 2141 | Line 1876 | public class CompletableFutureTest exten
1876  
1877          g.complete(v2);
1878          checkCompletedNormally(h, null);
1879 <        assertEquals(r.value, inc(v2));
1879 >        assertEquals(inc(v2), r.value);
1880          f.complete(v1);
1881  
1882          checkCompletedNormally(f, v1);
1883          checkCompletedNormally(g, v2);
1884          checkCompletedNormally(h, null);
1885 <        }
1886 <    }
1885 >    }}
1886 >
1887      public void testAcceptEither_normalCompletion3() {
1888          for (ExecutionMode m : ExecutionMode.values())
1889          for (Integer v1 : new Integer[] { 1, null })
1890 <        for (Integer v2 : new Integer[] { 2, null }) {
1891 <
1890 >        for (Integer v2 : new Integer[] { 2, null })
1891 >    {
1892          final CompletableFuture<Integer> f = new CompletableFuture<>();
1893          final CompletableFuture<Integer> g = new CompletableFuture<>();
1894          final IncAction r = new IncAction();
# Line 2169 | Line 1904 | public class CompletableFutureTest exten
1904          // unspecified behavior
1905          assertTrue(Objects.equals(r.value, inc(v1)) ||
1906                     Objects.equals(r.value, inc(v2)));
1907 <        }
2173 <    }
1907 >    }}
1908  
1909      /**
1910       * acceptEither result completes exceptionally after exceptional
# Line 2178 | Line 1912 | public class CompletableFutureTest exten
1912       */
1913      public void testAcceptEither_exceptionalCompletion1() {
1914          for (ExecutionMode m : ExecutionMode.values())
1915 <        for (Integer v1 : new Integer[] { 1, null }) {
1916 <
1915 >        for (Integer v1 : new Integer[] { 1, null })
1916 >    {
1917          final CompletableFuture<Integer> f = new CompletableFuture<>();
1918          final CompletableFuture<Integer> g = new CompletableFuture<>();
1919          final IncAction r = new IncAction();
# Line 2190 | Line 1924 | public class CompletableFutureTest exten
1924          checkCompletedWithWrappedCFException(h, ex);
1925          g.complete(v1);
1926  
1927 <        assertEquals(r.invocationCount, 0);
1927 >        assertEquals(0, r.invocationCount);
1928          checkCompletedNormally(g, v1);
1929          checkCompletedWithWrappedCFException(f, ex);
1930          checkCompletedWithWrappedCFException(h, ex);
1931 <        }
2198 <    }
1931 >    }}
1932  
1933      public void testAcceptEither_exceptionalCompletion2() {
1934          for (ExecutionMode m : ExecutionMode.values())
1935 <        for (Integer v1 : new Integer[] { 1, null }) {
1936 <
1935 >        for (Integer v1 : new Integer[] { 1, null })
1936 >    {
1937          final CompletableFuture<Integer> f = new CompletableFuture<>();
1938          final CompletableFuture<Integer> g = new CompletableFuture<>();
1939          final IncAction r = new IncAction();
# Line 2211 | Line 1944 | public class CompletableFutureTest exten
1944          checkCompletedWithWrappedCFException(h, ex);
1945          f.complete(v1);
1946  
1947 <        assertEquals(r.invocationCount, 0);
1947 >        assertEquals(0, r.invocationCount);
1948          checkCompletedNormally(f, v1);
1949          checkCompletedWithWrappedCFException(g, ex);
1950          checkCompletedWithWrappedCFException(h, ex);
1951 <        }
2219 <    }
1951 >    }}
1952  
1953      public void testAcceptEither_exceptionalCompletion3() {
1954          for (ExecutionMode m : ExecutionMode.values())
1955 <        for (Integer v1 : new Integer[] { 1, null }) {
1956 <
1955 >        for (Integer v1 : new Integer[] { 1, null })
1956 >    {
1957          final CompletableFuture<Integer> f = new CompletableFuture<>();
1958          final CompletableFuture<Integer> g = new CompletableFuture<>();
1959          final IncAction r = new IncAction();
# Line 2234 | Line 1966 | public class CompletableFutureTest exten
1966          // unspecified behavior
1967          Integer v;
1968          try {
1969 <            assertEquals(h.join(), null);
1970 <            assertEquals(r.invocationCount, 1);
1969 >            assertNull(h.join());
1970 >            assertEquals(1, r.invocationCount);
1971              assertEquals(inc(v1), r.value);
1972          } catch (CompletionException ok) {
1973              checkCompletedWithWrappedCFException(h, ex);
1974 <            assertEquals(r.invocationCount, 0);
1974 >            assertEquals(0, r.invocationCount);
1975          }
1976  
1977          checkCompletedWithWrappedCFException(g, ex);
1978          checkCompletedNormally(f, v1);
1979 <        }
2248 <    }
1979 >    }}
1980  
1981      public void testAcceptEither_exceptionalCompletion4() {
1982          for (ExecutionMode m : ExecutionMode.values())
1983 <        for (Integer v1 : new Integer[] { 1, null }) {
1984 <
1983 >        for (Integer v1 : new Integer[] { 1, null })
1984 >    {
1985          final CompletableFuture<Integer> f = new CompletableFuture<>();
1986          final CompletableFuture<Integer> g = new CompletableFuture<>();
1987          final IncAction r = new IncAction();
# Line 2263 | Line 1994 | public class CompletableFutureTest exten
1994          // unspecified behavior
1995          Integer v;
1996          try {
1997 <            assertEquals(h.join(), null);
1998 <            assertEquals(r.invocationCount, 1);
1997 >            assertNull(h.join());
1998 >            assertEquals(1, r.invocationCount);
1999              assertEquals(inc(v1), r.value);
2000          } catch (CompletionException ok) {
2001              checkCompletedWithWrappedCFException(h, ex);
2002 <            assertEquals(r.invocationCount, 0);
2002 >            assertEquals(0, r.invocationCount);
2003          }
2004  
2005          checkCompletedWithWrappedCFException(f, ex);
2006          checkCompletedNormally(g, v1);
2007 <        }
2277 <    }
2007 >    }}
2008  
2009      /**
2010       * acceptEither result completes exceptionally if action does
# Line 2282 | Line 2012 | public class CompletableFutureTest exten
2012      public void testAcceptEither_actionFailed1() {
2013          for (ExecutionMode m : ExecutionMode.values())
2014          for (Integer v1 : new Integer[] { 1, null })
2015 <        for (Integer v2 : new Integer[] { 2, null }) {
2016 <
2015 >        for (Integer v2 : new Integer[] { 2, null })
2016 >    {
2017          final CompletableFuture<Integer> f = new CompletableFuture<>();
2018          final CompletableFuture<Integer> g = new CompletableFuture<>();
2019          final FailingConsumer r = new FailingConsumer();
# Line 2294 | Line 2024 | public class CompletableFutureTest exten
2024          g.complete(v2);
2025          checkCompletedNormally(f, v1);
2026          checkCompletedNormally(g, v2);
2027 <        }
2298 <    }
2027 >    }}
2028  
2029      public void testAcceptEither_actionFailed2() {
2030          for (ExecutionMode m : ExecutionMode.values())
2031          for (Integer v1 : new Integer[] { 1, null })
2032 <        for (Integer v2 : new Integer[] { 2, null }) {
2033 <
2032 >        for (Integer v2 : new Integer[] { 2, null })
2033 >    {
2034          final CompletableFuture<Integer> f = new CompletableFuture<>();
2035          final CompletableFuture<Integer> g = new CompletableFuture<>();
2036          final FailingConsumer r = new FailingConsumer();
# Line 2312 | Line 2041 | public class CompletableFutureTest exten
2041          f.complete(v1);
2042          checkCompletedNormally(f, v1);
2043          checkCompletedNormally(g, v2);
2044 <        }
2316 <    }
2044 >    }}
2045  
2046      /**
2047       * acceptEither result completes exceptionally if either source cancelled
# Line 2321 | Line 2049 | public class CompletableFutureTest exten
2049      public void testAcceptEither_sourceCancelled1() {
2050          for (ExecutionMode m : ExecutionMode.values())
2051          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2052 <        for (Integer v1 : new Integer[] { 1, null }) {
2053 <
2052 >        for (Integer v1 : new Integer[] { 1, null })
2053 >    {
2054          final CompletableFuture<Integer> f = new CompletableFuture<>();
2055          final CompletableFuture<Integer> g = new CompletableFuture<>();
2056          final IncAction r = new IncAction();
# Line 2333 | Line 2061 | public class CompletableFutureTest exten
2061          g.complete(v1);
2062  
2063          checkCancelled(f);
2064 <        assertEquals(r.invocationCount, 0);
2064 >        assertEquals(0, r.invocationCount);
2065          checkCompletedNormally(g, v1);
2066          checkCompletedWithWrappedCancellationException(h);
2067 <        }
2340 <    }
2067 >    }}
2068  
2069      public void testAcceptEither_sourceCancelled2() {
2070          for (ExecutionMode m : ExecutionMode.values())
2071          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2072 <        for (Integer v1 : new Integer[] { 1, null }) {
2073 <
2072 >        for (Integer v1 : new Integer[] { 1, null })
2073 >    {
2074          final CompletableFuture<Integer> f = new CompletableFuture<>();
2075          final CompletableFuture<Integer> g = new CompletableFuture<>();
2076          final IncAction r = new IncAction();
# Line 2354 | Line 2081 | public class CompletableFutureTest exten
2081          f.complete(v1);
2082  
2083          checkCancelled(g);
2084 <        assertEquals(r.invocationCount, 0);
2084 >        assertEquals(0, r.invocationCount);
2085          checkCompletedNormally(f, v1);
2086          checkCompletedWithWrappedCancellationException(h);
2087 <        }
2361 <    }
2087 >    }}
2088  
2089      public void testAcceptEither_sourceCancelled3() {
2090          for (ExecutionMode m : ExecutionMode.values())
2091          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2092 <        for (Integer v1 : new Integer[] { 1, null }) {
2093 <
2092 >        for (Integer v1 : new Integer[] { 1, null })
2093 >    {
2094          final CompletableFuture<Integer> f = new CompletableFuture<>();
2095          final CompletableFuture<Integer> g = new CompletableFuture<>();
2096          final IncAction r = new IncAction();
# Line 2376 | Line 2102 | public class CompletableFutureTest exten
2102          // unspecified behavior
2103          Integer v;
2104          try {
2105 <            assertEquals(h.join(), null);
2106 <            assertEquals(r.invocationCount, 1);
2105 >            assertNull(h.join());
2106 >            assertEquals(1, r.invocationCount);
2107              assertEquals(inc(v1), r.value);
2108          } catch (CompletionException ok) {
2109              checkCompletedWithWrappedCancellationException(h);
2110 <            assertEquals(r.invocationCount, 0);
2110 >            assertEquals(0, r.invocationCount);
2111          }
2112  
2113          checkCancelled(g);
2114          checkCompletedNormally(f, v1);
2115 <        }
2390 <    }
2115 >    }}
2116  
2117      public void testAcceptEither_sourceCancelled4() {
2118          for (ExecutionMode m : ExecutionMode.values())
2119          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2120 <        for (Integer v1 : new Integer[] { 1, null }) {
2121 <
2120 >        for (Integer v1 : new Integer[] { 1, null })
2121 >    {
2122          final CompletableFuture<Integer> f = new CompletableFuture<>();
2123          final CompletableFuture<Integer> g = new CompletableFuture<>();
2124          final IncAction r = new IncAction();
# Line 2405 | Line 2130 | public class CompletableFutureTest exten
2130          // unspecified behavior
2131          Integer v;
2132          try {
2133 <            assertEquals(h.join(), null);
2134 <            assertEquals(r.invocationCount, 1);
2133 >            assertNull(h.join());
2134 >            assertEquals(1, r.invocationCount);
2135              assertEquals(inc(v1), r.value);
2136          } catch (CompletionException ok) {
2137              checkCompletedWithWrappedCancellationException(h);
2138 <            assertEquals(r.invocationCount, 0);
2138 >            assertEquals(0, r.invocationCount);
2139          }
2140  
2141          checkCancelled(f);
2142          checkCompletedNormally(g, v1);
2143 <        }
2419 <    }
2143 >    }}
2144  
2145      /**
2146       * runAfterEither result completes normally after normal completion
# Line 2425 | Line 2149 | public class CompletableFutureTest exten
2149      public void testRunAfterEither_normalCompletion1() {
2150          for (ExecutionMode m : ExecutionMode.values())
2151          for (Integer v1 : new Integer[] { 1, null })
2152 <        for (Integer v2 : new Integer[] { 2, null }) {
2153 <
2152 >        for (Integer v2 : new Integer[] { 2, null })
2153 >    {
2154          final CompletableFuture<Integer> f = new CompletableFuture<>();
2155          final CompletableFuture<Integer> g = new CompletableFuture<>();
2156          final Noop r = new Noop();
# Line 2434 | Line 2158 | public class CompletableFutureTest exten
2158  
2159          f.complete(v1);
2160          checkCompletedNormally(h, null);
2161 <        assertEquals(r.invocationCount, 1);
2161 >        assertEquals(1, r.invocationCount);
2162          g.complete(v2);
2163  
2164          checkCompletedNormally(f, v1);
2165          checkCompletedNormally(g, v2);
2166          checkCompletedNormally(h, null);
2167 <        assertEquals(r.invocationCount, 1);
2168 <        }
2445 <    }
2167 >        assertEquals(1, r.invocationCount);
2168 >    }}
2169  
2170      public void testRunAfterEither_normalCompletion2() {
2171          for (ExecutionMode m : ExecutionMode.values())
2172          for (Integer v1 : new Integer[] { 1, null })
2173 <        for (Integer v2 : new Integer[] { 2, null }) {
2174 <
2173 >        for (Integer v2 : new Integer[] { 2, null })
2174 >    {
2175          final CompletableFuture<Integer> f = new CompletableFuture<>();
2176          final CompletableFuture<Integer> g = new CompletableFuture<>();
2177          final Noop r = new Noop();
# Line 2456 | Line 2179 | public class CompletableFutureTest exten
2179  
2180          g.complete(v2);
2181          checkCompletedNormally(h, null);
2182 <        assertEquals(r.invocationCount, 1);
2182 >        assertEquals(1, r.invocationCount);
2183          f.complete(v1);
2184  
2185          checkCompletedNormally(f, v1);
2186          checkCompletedNormally(g, v2);
2187          checkCompletedNormally(h, null);
2188 <        assertEquals(r.invocationCount, 1);
2189 <        }
2190 <    }
2188 >        assertEquals(1, r.invocationCount);
2189 >        }}
2190 >
2191      public void testRunAfterEither_normalCompletion3() {
2192          for (ExecutionMode m : ExecutionMode.values())
2193          for (Integer v1 : new Integer[] { 1, null })
2194 <        for (Integer v2 : new Integer[] { 2, null }) {
2195 <
2194 >        for (Integer v2 : new Integer[] { 2, null })
2195 >    {
2196          final CompletableFuture<Integer> f = new CompletableFuture<>();
2197          final CompletableFuture<Integer> g = new CompletableFuture<>();
2198          final Noop r = new Noop();
# Line 2481 | Line 2204 | public class CompletableFutureTest exten
2204          checkCompletedNormally(h, null);
2205          checkCompletedNormally(f, v1);
2206          checkCompletedNormally(g, v2);
2207 <        assertEquals(r.invocationCount, 1);
2208 <        }
2486 <    }
2207 >        assertEquals(1, r.invocationCount);
2208 >    }}
2209  
2210      /**
2211       * runAfterEither result completes exceptionally after exceptional
# Line 2491 | Line 2213 | public class CompletableFutureTest exten
2213       */
2214      public void testRunAfterEither_exceptionalCompletion1() {
2215          for (ExecutionMode m : ExecutionMode.values())
2216 <        for (Integer v1 : new Integer[] { 1, null }) {
2217 <
2216 >        for (Integer v1 : new Integer[] { 1, null })
2217 >    {
2218          final CompletableFuture<Integer> f = new CompletableFuture<>();
2219          final CompletableFuture<Integer> g = new CompletableFuture<>();
2220          final Noop r = new Noop();
# Line 2503 | Line 2225 | public class CompletableFutureTest exten
2225          checkCompletedWithWrappedCFException(h, ex);
2226          g.complete(v1);
2227  
2228 <        assertEquals(r.invocationCount, 0);
2228 >        assertEquals(0, r.invocationCount);
2229          checkCompletedNormally(g, v1);
2230          checkCompletedWithWrappedCFException(f, ex);
2231          checkCompletedWithWrappedCFException(h, ex);
2232 <        }
2511 <    }
2232 >    }}
2233  
2234      public void testRunAfterEither_exceptionalCompletion2() {
2235          for (ExecutionMode m : ExecutionMode.values())
2236 <        for (Integer v1 : new Integer[] { 1, null }) {
2237 <
2236 >        for (Integer v1 : new Integer[] { 1, null })
2237 >    {
2238          final CompletableFuture<Integer> f = new CompletableFuture<>();
2239          final CompletableFuture<Integer> g = new CompletableFuture<>();
2240          final Noop r = new Noop();
# Line 2524 | Line 2245 | public class CompletableFutureTest exten
2245          checkCompletedWithWrappedCFException(h, ex);
2246          f.complete(v1);
2247  
2248 <        assertEquals(r.invocationCount, 0);
2248 >        assertEquals(0, r.invocationCount);
2249          checkCompletedNormally(f, v1);
2250          checkCompletedWithWrappedCFException(g, ex);
2251          checkCompletedWithWrappedCFException(h, ex);
2252 <        }
2532 <    }
2252 >    }}
2253  
2254      public void testRunAfterEither_exceptionalCompletion3() {
2255          for (ExecutionMode m : ExecutionMode.values())
2256 <        for (Integer v1 : new Integer[] { 1, null }) {
2257 <
2256 >        for (Integer v1 : new Integer[] { 1, null })
2257 >    {
2258          final CompletableFuture<Integer> f = new CompletableFuture<>();
2259          final CompletableFuture<Integer> g = new CompletableFuture<>();
2260          final Noop r = new Noop();
# Line 2547 | Line 2267 | public class CompletableFutureTest exten
2267          // unspecified behavior
2268          Integer v;
2269          try {
2270 <            assertEquals(h.join(), null);
2271 <            assertEquals(r.invocationCount, 1);
2270 >            assertNull(h.join());
2271 >            assertEquals(1, r.invocationCount);
2272          } catch (CompletionException ok) {
2273              checkCompletedWithWrappedCFException(h, ex);
2274 <            assertEquals(r.invocationCount, 0);
2274 >            assertEquals(0, r.invocationCount);
2275          }
2276  
2277          checkCompletedWithWrappedCFException(g, ex);
2278          checkCompletedNormally(f, v1);
2279 <        }
2560 <    }
2279 >    }}
2280  
2281      public void testRunAfterEither_exceptionalCompletion4() {
2282          for (ExecutionMode m : ExecutionMode.values())
2283 <        for (Integer v1 : new Integer[] { 1, null }) {
2284 <
2283 >        for (Integer v1 : new Integer[] { 1, null })
2284 >    {
2285          final CompletableFuture<Integer> f = new CompletableFuture<>();
2286          final CompletableFuture<Integer> g = new CompletableFuture<>();
2287          final Noop r = new Noop();
# Line 2575 | Line 2294 | public class CompletableFutureTest exten
2294          // unspecified behavior
2295          Integer v;
2296          try {
2297 <            assertEquals(h.join(), null);
2298 <            assertEquals(r.invocationCount, 1);
2297 >            assertNull(h.join());
2298 >            assertEquals(1, r.invocationCount);
2299          } catch (CompletionException ok) {
2300              checkCompletedWithWrappedCFException(h, ex);
2301 <            assertEquals(r.invocationCount, 0);
2301 >            assertEquals(0, r.invocationCount);
2302          }
2303  
2304          checkCompletedWithWrappedCFException(f, ex);
2305          checkCompletedNormally(g, v1);
2306 <        }
2588 <    }
2306 >    }}
2307  
2308      /**
2309       * runAfterEither result completes exceptionally if action does
# Line 2593 | Line 2311 | public class CompletableFutureTest exten
2311      public void testRunAfterEither_actionFailed1() {
2312          for (ExecutionMode m : ExecutionMode.values())
2313          for (Integer v1 : new Integer[] { 1, null })
2314 <        for (Integer v2 : new Integer[] { 2, null }) {
2315 <
2314 >        for (Integer v2 : new Integer[] { 2, null })
2315 >    {
2316          final CompletableFuture<Integer> f = new CompletableFuture<>();
2317          final CompletableFuture<Integer> g = new CompletableFuture<>();
2318 <        final FailingNoop r = new FailingNoop();
2318 >        final FailingRunnable r = new FailingRunnable();
2319          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2320  
2321          f.complete(v1);
# Line 2605 | Line 2323 | public class CompletableFutureTest exten
2323          g.complete(v2);
2324          checkCompletedNormally(f, v1);
2325          checkCompletedNormally(g, v2);
2326 <        }
2609 <    }
2326 >    }}
2327  
2328      public void testRunAfterEither_actionFailed2() {
2329          for (ExecutionMode m : ExecutionMode.values())
2330          for (Integer v1 : new Integer[] { 1, null })
2331 <        for (Integer v2 : new Integer[] { 2, null }) {
2332 <
2331 >        for (Integer v2 : new Integer[] { 2, null })
2332 >    {
2333          final CompletableFuture<Integer> f = new CompletableFuture<>();
2334          final CompletableFuture<Integer> g = new CompletableFuture<>();
2335 <        final FailingNoop r = new FailingNoop();
2335 >        final FailingRunnable r = new FailingRunnable();
2336          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2337  
2338          g.complete(v2);
# Line 2623 | Line 2340 | public class CompletableFutureTest exten
2340          f.complete(v1);
2341          checkCompletedNormally(f, v1);
2342          checkCompletedNormally(g, v2);
2343 <        }
2627 <    }
2343 >    }}
2344  
2345      /**
2346       * runAfterEither result completes exceptionally if either source cancelled
# Line 2632 | Line 2348 | public class CompletableFutureTest exten
2348      public void testRunAfterEither_sourceCancelled1() {
2349          for (ExecutionMode m : ExecutionMode.values())
2350          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2351 <        for (Integer v1 : new Integer[] { 1, null }) {
2352 <
2351 >        for (Integer v1 : new Integer[] { 1, null })
2352 >    {
2353          final CompletableFuture<Integer> f = new CompletableFuture<>();
2354          final CompletableFuture<Integer> g = new CompletableFuture<>();
2355          final Noop r = new Noop();
# Line 2644 | Line 2360 | public class CompletableFutureTest exten
2360          g.complete(v1);
2361  
2362          checkCancelled(f);
2363 <        assertEquals(r.invocationCount, 0);
2363 >        assertEquals(0, r.invocationCount);
2364          checkCompletedNormally(g, v1);
2365          checkCompletedWithWrappedCancellationException(h);
2366 <        }
2651 <    }
2366 >    }}
2367  
2368      public void testRunAfterEither_sourceCancelled2() {
2369          for (ExecutionMode m : ExecutionMode.values())
2370          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2371 <        for (Integer v1 : new Integer[] { 1, null }) {
2372 <
2371 >        for (Integer v1 : new Integer[] { 1, null })
2372 >    {
2373          final CompletableFuture<Integer> f = new CompletableFuture<>();
2374          final CompletableFuture<Integer> g = new CompletableFuture<>();
2375          final Noop r = new Noop();
# Line 2665 | Line 2380 | public class CompletableFutureTest exten
2380          f.complete(v1);
2381  
2382          checkCancelled(g);
2383 <        assertEquals(r.invocationCount, 0);
2383 >        assertEquals(0, r.invocationCount);
2384          checkCompletedNormally(f, v1);
2385          checkCompletedWithWrappedCancellationException(h);
2386 <        }
2672 <    }
2386 >    }}
2387  
2388      public void testRunAfterEither_sourceCancelled3() {
2389          for (ExecutionMode m : ExecutionMode.values())
2390          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2391 <        for (Integer v1 : new Integer[] { 1, null }) {
2392 <
2391 >        for (Integer v1 : new Integer[] { 1, null })
2392 >    {
2393          final CompletableFuture<Integer> f = new CompletableFuture<>();
2394          final CompletableFuture<Integer> g = new CompletableFuture<>();
2395          final Noop r = new Noop();
# Line 2687 | Line 2401 | public class CompletableFutureTest exten
2401          // unspecified behavior
2402          Integer v;
2403          try {
2404 <            assertEquals(h.join(), null);
2405 <            assertEquals(r.invocationCount, 1);
2404 >            assertNull(h.join());
2405 >            assertEquals(1, r.invocationCount);
2406          } catch (CompletionException ok) {
2407              checkCompletedWithWrappedCancellationException(h);
2408 <            assertEquals(r.invocationCount, 0);
2408 >            assertEquals(0, r.invocationCount);
2409          }
2410  
2411          checkCancelled(g);
2412          checkCompletedNormally(f, v1);
2413 <        }
2700 <    }
2413 >    }}
2414  
2415      public void testRunAfterEither_sourceCancelled4() {
2416          for (ExecutionMode m : ExecutionMode.values())
2417          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2418 <        for (Integer v1 : new Integer[] { 1, null }) {
2419 <
2418 >        for (Integer v1 : new Integer[] { 1, null })
2419 >    {
2420          final CompletableFuture<Integer> f = new CompletableFuture<>();
2421          final CompletableFuture<Integer> g = new CompletableFuture<>();
2422          final Noop r = new Noop();
# Line 2715 | Line 2428 | public class CompletableFutureTest exten
2428          // unspecified behavior
2429          Integer v;
2430          try {
2431 <            assertEquals(h.join(), null);
2432 <            assertEquals(r.invocationCount, 1);
2431 >            assertNull(h.join());
2432 >            assertEquals(1, r.invocationCount);
2433          } catch (CompletionException ok) {
2434              checkCompletedWithWrappedCancellationException(h);
2435 <            assertEquals(r.invocationCount, 0);
2435 >            assertEquals(0, r.invocationCount);
2436          }
2437  
2438          checkCancelled(f);
2439          checkCompletedNormally(g, v1);
2440 <        }
2728 <    }
2440 >    }}
2441  
2442      /**
2443       * thenCompose result completes normally after normal completion of source
2444       */
2445 <    public void testThenCompose() {
2446 <        CompletableFuture<Integer> f, g;
2447 <        CompletableFutureInc r;
2448 <
2449 <        f = new CompletableFuture<>();
2450 <        g = f.thenCompose(r = new CompletableFutureInc());
2451 <        f.complete(one);
2452 <        checkCompletedNormally(g, two);
2453 <        assertTrue(r.ran);
2445 >    public void testThenCompose_normalCompletion() {
2446 >        for (ExecutionMode m : ExecutionMode.values())
2447 >        for (boolean createIncomplete : new boolean[] { true, false })
2448 >        for (Integer v1 : new Integer[] { 1, null })
2449 >    {
2450 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2451 >        final CompletableFutureInc r = new CompletableFutureInc();
2452 >        if (!createIncomplete) f.complete(v1);
2453 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2454 >        if (createIncomplete) f.complete(v1);
2455  
2456 <        f = new CompletableFuture<>();
2457 <        f.complete(one);
2458 <        g = f.thenCompose(r = new CompletableFutureInc());
2459 <        checkCompletedNormally(g, two);
2747 <        assertTrue(r.ran);
2748 <    }
2456 >        checkCompletedNormally(g, inc(v1));
2457 >        checkCompletedNormally(f, v1);
2458 >        assertEquals(1, r.invocationCount);
2459 >    }}
2460  
2461      /**
2462       * thenCompose result completes exceptionally after exceptional
2463       * completion of source
2464       */
2465 <    public void testThenCompose2() {
2466 <        CompletableFuture<Integer> f, g;
2467 <        CompletableFutureInc r;
2468 <
2469 <        f = new CompletableFuture<>();
2470 <        g = f.thenCompose(r = new CompletableFutureInc());
2471 <        f.completeExceptionally(new CFException());
2472 <        checkCompletedWithWrappedCFException(g);
2465 >    public void testThenCompose_exceptionalCompletion() {
2466 >        for (ExecutionMode m : ExecutionMode.values())
2467 >        for (boolean createIncomplete : new boolean[] { true, false })
2468 >    {
2469 >        final CFException ex = new CFException();
2470 >        final CompletableFutureInc r = new CompletableFutureInc();
2471 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2472 >        if (!createIncomplete) f.completeExceptionally(ex);
2473 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2474 >        if (createIncomplete) f.completeExceptionally(ex);
2475  
2476 <        f = new CompletableFuture<>();
2477 <        f.completeExceptionally(new CFException());
2478 <        g = f.thenCompose(r = new CompletableFutureInc());
2479 <        checkCompletedWithWrappedCFException(g);
2767 <    }
2476 >        checkCompletedWithWrappedCFException(g, ex);
2477 >        checkCompletedWithWrappedCFException(f, ex);
2478 >        assertEquals(0, r.invocationCount);
2479 >    }}
2480  
2481      /**
2482       * thenCompose result completes exceptionally if action does
2483       */
2484 <    public void testThenCompose3() {
2485 <        CompletableFuture<Integer> f, g;
2486 <        FailingCompletableFutureFunction r;
2487 <
2488 <        f = new CompletableFuture<>();
2489 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2490 <        f.complete(one);
2491 <        checkCompletedWithWrappedCFException(g);
2484 >    public void testThenCompose_actionFailed() {
2485 >        for (ExecutionMode m : ExecutionMode.values())
2486 >        for (boolean createIncomplete : new boolean[] { true, false })
2487 >        for (Integer v1 : new Integer[] { 1, null })
2488 >    {
2489 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2490 >        final FailingCompletableFutureFunction r
2491 >            = new FailingCompletableFutureFunction();
2492 >        if (!createIncomplete) f.complete(v1);
2493 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2494 >        if (createIncomplete) f.complete(v1);
2495  
2781        f = new CompletableFuture<>();
2782        f.complete(one);
2783        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2496          checkCompletedWithWrappedCFException(g);
2497 <    }
2497 >        checkCompletedNormally(f, v1);
2498 >    }}
2499  
2500      /**
2501       * thenCompose result completes exceptionally if source cancelled
2502       */
2503 <    public void testThenCompose4() {
2504 <        CompletableFuture<Integer> f, g;
2505 <        CompletableFutureInc r;
2506 <
2507 <        f = new CompletableFuture<>();
2508 <        g = f.thenCompose(r = new CompletableFutureInc());
2509 <        assertTrue(f.cancel(true));
2510 <        checkCompletedWithWrappedCancellationException(g);
2511 <
2512 <        f = new CompletableFuture<>();
2513 <        assertTrue(f.cancel(true));
2514 <        g = f.thenCompose(r = new CompletableFutureInc());
2515 <        checkCompletedWithWrappedCancellationException(g);
2803 <    }
2804 <
2805 <    // asyncs
2806 <
2807 <    /**
2808 <     * thenRunAsync result completes normally after normal completion of source
2809 <     */
2810 <    public void testThenRunAsync() {
2811 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2812 <        Noop r = new Noop();
2813 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2814 <        f.complete(null);
2815 <        checkCompletedNormally(g, null);
2816 <
2817 <        // reordered version
2818 <        f = new CompletableFuture<>();
2819 <        f.complete(null);
2820 <        r = new Noop();
2821 <        g = f.thenRunAsync(r);
2822 <        checkCompletedNormally(g, null);
2823 <    }
2824 <
2825 <    /**
2826 <     * thenRunAsync result completes exceptionally after exceptional
2827 <     * completion of source
2828 <     */
2829 <    public void testThenRunAsync2() {
2830 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2831 <        Noop r = new Noop();
2832 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2833 <        f.completeExceptionally(new CFException());
2834 <        try {
2835 <            g.join();
2836 <            shouldThrow();
2837 <        } catch (CompletionException success) {}
2838 <        checkCompletedWithWrappedCFException(g);
2839 <    }
2840 <
2841 <    /**
2842 <     * thenRunAsync result completes exceptionally if action does
2843 <     */
2844 <    public void testThenRunAsync3() {
2845 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2846 <        FailingNoop r = new FailingNoop();
2847 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2848 <        f.complete(null);
2849 <        checkCompletedWithWrappedCFException(g);
2850 <    }
2851 <
2852 <    /**
2853 <     * thenRunAsync result completes exceptionally if source cancelled
2854 <     */
2855 <    public void testThenRunAsync4() {
2856 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2857 <        Noop r = new Noop();
2858 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2859 <        assertTrue(f.cancel(true));
2860 <        checkCompletedWithWrappedCancellationException(g);
2861 <    }
2862 <
2863 <    /**
2864 <     * thenApplyAsync result completes normally after normal completion of source
2865 <     */
2866 <    public void testThenApplyAsync() {
2867 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2868 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2869 <        f.complete(one);
2870 <        checkCompletedNormally(g, two);
2871 <    }
2872 <
2873 <    /**
2874 <     * thenApplyAsync result completes exceptionally after exceptional
2875 <     * completion of source
2876 <     */
2877 <    public void testThenApplyAsync2() {
2878 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2879 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2880 <        f.completeExceptionally(new CFException());
2881 <        checkCompletedWithWrappedCFException(g);
2882 <    }
2883 <
2884 <    /**
2885 <     * thenApplyAsync result completes exceptionally if action does
2886 <     */
2887 <    public void testThenApplyAsync3() {
2888 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2889 <        FailingFunction r = new FailingFunction();
2890 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2891 <        f.complete(null);
2892 <        checkCompletedWithWrappedCFException(g);
2893 <    }
2894 <
2895 <    /**
2896 <     * thenApplyAsync result completes exceptionally if source cancelled
2897 <     */
2898 <    public void testThenApplyAsync4() {
2899 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2900 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2901 <        assertTrue(f.cancel(true));
2902 <        checkCompletedWithWrappedCancellationException(g);
2903 <    }
2904 <
2905 <    /**
2906 <     * thenAcceptAsync result completes normally after normal
2907 <     * completion of source
2908 <     */
2909 <    public void testThenAcceptAsync() {
2910 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2911 <        IncAction r = new IncAction();
2912 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2913 <        f.complete(one);
2914 <        checkCompletedNormally(g, null);
2915 <        assertEquals(r.value, (Integer) 2);
2916 <    }
2917 <
2918 <    /**
2919 <     * thenAcceptAsync result completes exceptionally after exceptional
2920 <     * completion of source
2921 <     */
2922 <    public void testThenAcceptAsync2() {
2923 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2924 <        IncAction r = new IncAction();
2925 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2926 <        f.completeExceptionally(new CFException());
2927 <        checkCompletedWithWrappedCFException(g);
2928 <    }
2929 <
2930 <    /**
2931 <     * thenAcceptAsync result completes exceptionally if action does
2932 <     */
2933 <    public void testThenAcceptAsync3() {
2934 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2935 <        FailingConsumer r = new FailingConsumer();
2936 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2937 <        f.complete(null);
2938 <        checkCompletedWithWrappedCFException(g);
2939 <    }
2940 <
2941 <    /**
2942 <     * thenAcceptAsync result completes exceptionally if source cancelled
2943 <     */
2944 <    public void testThenAcceptAsync4() {
2945 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2946 <        IncAction r = new IncAction();
2947 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2948 <        assertTrue(f.cancel(true));
2949 <        checkCompletedWithWrappedCancellationException(g);
2950 <    }
2951 <
2952 <    /**
2953 <     * thenComposeAsync result completes normally after normal
2954 <     * completion of source
2955 <     */
2956 <    public void testThenComposeAsync() {
2957 <        CompletableFuture<Integer> f, g;
2958 <        CompletableFutureInc r;
2959 <
2960 <        f = new CompletableFuture<>();
2961 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2962 <        f.complete(one);
2963 <        checkCompletedNormally(g, two);
2964 <
2965 <        f = new CompletableFuture<>();
2966 <        f.complete(one);
2967 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2968 <        checkCompletedNormally(g, two);
2969 <    }
2970 <
2971 <    /**
2972 <     * thenComposeAsync result completes exceptionally after
2973 <     * exceptional completion of source
2974 <     */
2975 <    public void testThenComposeAsync2() {
2976 <        CompletableFuture<Integer> f, g;
2977 <        CompletableFutureInc r;
2978 <
2979 <        f = new CompletableFuture<>();
2980 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2981 <        f.completeExceptionally(new CFException());
2982 <        checkCompletedWithWrappedCFException(g);
2983 <        assertFalse(r.ran);
2984 <
2985 <        f = new CompletableFuture<>();
2986 <        f.completeExceptionally(new CFException());
2987 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2988 <        checkCompletedWithWrappedCFException(g);
2989 <        assertFalse(r.ran);
2990 <    }
2991 <
2992 <    /**
2993 <     * thenComposeAsync result completes exceptionally if action does
2994 <     */
2995 <    public void testThenComposeAsync3() {
2996 <        CompletableFuture<Integer> f, g;
2997 <        FailingCompletableFutureFunction r;
2998 <
2999 <        f = new CompletableFuture<>();
3000 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3001 <        f.complete(one);
3002 <        checkCompletedWithWrappedCFException(g);
3003 <
3004 <        f = new CompletableFuture<>();
3005 <        f.complete(one);
3006 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3007 <        checkCompletedWithWrappedCFException(g);
3008 <    }
3009 <
3010 <    /**
3011 <     * thenComposeAsync result completes exceptionally if source cancelled
3012 <     */
3013 <    public void testThenComposeAsync4() {
3014 <        CompletableFuture<Integer> f, g;
3015 <        CompletableFutureInc r;
3016 <
3017 <        f = new CompletableFuture<>();
3018 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3019 <        assertTrue(f.cancel(true));
3020 <        checkCompletedWithWrappedCancellationException(g);
3021 <
3022 <        f = new CompletableFuture<>();
3023 <        assertTrue(f.cancel(true));
3024 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3025 <        checkCompletedWithWrappedCancellationException(g);
3026 <    }
3027 <
3028 <    // async with explicit executors
3029 <
3030 <    /**
3031 <     * thenRunAsync result completes normally after normal completion of source
3032 <     */
3033 <    public void testThenRunAsyncE() {
3034 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3035 <        Noop r = new Noop();
3036 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3037 <        f.complete(null);
3038 <        checkCompletedNormally(g, null);
3039 <
3040 <        // reordered version
3041 <        f = new CompletableFuture<>();
3042 <        f.complete(null);
3043 <        r = new Noop();
3044 <        g = f.thenRunAsync(r, new ThreadExecutor());
3045 <        checkCompletedNormally(g, null);
3046 <    }
3047 <
3048 <    /**
3049 <     * thenRunAsync result completes exceptionally after exceptional
3050 <     * completion of source
3051 <     */
3052 <    public void testThenRunAsync2E() {
3053 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3054 <        Noop r = new Noop();
3055 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3056 <        f.completeExceptionally(new CFException());
3057 <        try {
3058 <            g.join();
3059 <            shouldThrow();
3060 <        } catch (CompletionException success) {}
3061 <        checkCompletedWithWrappedCFException(g);
3062 <    }
3063 <
3064 <    /**
3065 <     * thenRunAsync result completes exceptionally if action does
3066 <     */
3067 <    public void testThenRunAsync3E() {
3068 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3069 <        FailingNoop r = new FailingNoop();
3070 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3071 <        f.complete(null);
3072 <        checkCompletedWithWrappedCFException(g);
3073 <    }
3074 <
3075 <    /**
3076 <     * thenRunAsync result completes exceptionally if source cancelled
3077 <     */
3078 <    public void testThenRunAsync4E() {
3079 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3080 <        Noop r = new Noop();
3081 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3082 <        assertTrue(f.cancel(true));
3083 <        checkCompletedWithWrappedCancellationException(g);
3084 <    }
3085 <
3086 <    /**
3087 <     * thenApplyAsync result completes normally after normal completion of source
3088 <     */
3089 <    public void testThenApplyAsyncE() {
3090 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3091 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3092 <        f.complete(one);
3093 <        checkCompletedNormally(g, two);
3094 <    }
3095 <
3096 <    /**
3097 <     * thenApplyAsync result completes exceptionally after exceptional
3098 <     * completion of source
3099 <     */
3100 <    public void testThenApplyAsync2E() {
3101 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3102 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3103 <        f.completeExceptionally(new CFException());
3104 <        checkCompletedWithWrappedCFException(g);
3105 <    }
3106 <
3107 <    /**
3108 <     * thenApplyAsync result completes exceptionally if action does
3109 <     */
3110 <    public void testThenApplyAsync3E() {
3111 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3112 <        FailingFunction r = new FailingFunction();
3113 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3114 <        f.complete(null);
3115 <        checkCompletedWithWrappedCFException(g);
3116 <    }
3117 <
3118 <    /**
3119 <     * thenApplyAsync result completes exceptionally if source cancelled
3120 <     */
3121 <    public void testThenApplyAsync4E() {
3122 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3123 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3124 <        assertTrue(f.cancel(true));
3125 <        checkCompletedWithWrappedCancellationException(g);
3126 <    }
3127 <
3128 <    /**
3129 <     * thenAcceptAsync result completes normally after normal
3130 <     * completion of source
3131 <     */
3132 <    public void testThenAcceptAsyncE() {
3133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3134 <        IncAction r = new IncAction();
3135 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3136 <        f.complete(one);
3137 <        checkCompletedNormally(g, null);
3138 <        assertEquals(r.value, (Integer) 2);
3139 <    }
3140 <
3141 <    /**
3142 <     * thenAcceptAsync result completes exceptionally after exceptional
3143 <     * completion of source
3144 <     */
3145 <    public void testThenAcceptAsync2E() {
3146 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3147 <        IncAction r = new IncAction();
3148 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3149 <        f.completeExceptionally(new CFException());
3150 <        checkCompletedWithWrappedCFException(g);
3151 <    }
3152 <
3153 <    /**
3154 <     * thenAcceptAsync result completes exceptionally if action does
3155 <     */
3156 <    public void testThenAcceptAsync3E() {
3157 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3158 <        FailingConsumer r = new FailingConsumer();
3159 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3160 <        f.complete(null);
3161 <        checkCompletedWithWrappedCFException(g);
3162 <    }
3163 <
3164 <    /**
3165 <     * thenAcceptAsync result completes exceptionally if source cancelled
3166 <     */
3167 <    public void testThenAcceptAsync4E() {
3168 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3169 <        IncAction r = new IncAction();
3170 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3171 <        assertTrue(f.cancel(true));
3172 <        checkCompletedWithWrappedCancellationException(g);
3173 <    }
3174 <
3175 <    /**
3176 <     * thenComposeAsync result completes normally after normal
3177 <     * completion of source
3178 <     */
3179 <    public void testThenComposeAsyncE() {
3180 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3181 <        CompletableFutureInc r = new CompletableFutureInc();
3182 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3183 <        f.complete(one);
3184 <        checkCompletedNormally(g, two);
3185 <    }
3186 <
3187 <    /**
3188 <     * thenComposeAsync result completes exceptionally after
3189 <     * exceptional completion of source
3190 <     */
3191 <    public void testThenComposeAsync2E() {
3192 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3193 <        CompletableFutureInc r = new CompletableFutureInc();
3194 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3195 <        f.completeExceptionally(new CFException());
3196 <        checkCompletedWithWrappedCFException(g);
3197 <    }
3198 <
3199 <    /**
3200 <     * thenComposeAsync result completes exceptionally if action does
3201 <     */
3202 <    public void testThenComposeAsync3E() {
3203 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3204 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
3205 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3206 <        f.complete(one);
3207 <        checkCompletedWithWrappedCFException(g);
3208 <    }
2503 >    public void testThenCompose_sourceCancelled() {
2504 >        for (ExecutionMode m : ExecutionMode.values())
2505 >        for (boolean createIncomplete : new boolean[] { true, false })
2506 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2507 >    {
2508 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2509 >        final CompletableFutureInc r = new CompletableFutureInc();
2510 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2511 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2512 >        if (createIncomplete) {
2513 >            checkIncomplete(g);
2514 >            assertTrue(f.cancel(mayInterruptIfRunning));
2515 >        }
2516  
3210    /**
3211     * thenComposeAsync result completes exceptionally if source cancelled
3212     */
3213    public void testThenComposeAsync4E() {
3214        CompletableFuture<Integer> f = new CompletableFuture<>();
3215        CompletableFutureInc r = new CompletableFutureInc();
3216        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3217        assertTrue(f.cancel(true));
2517          checkCompletedWithWrappedCancellationException(g);
2518 <    }
2518 >        checkCancelled(f);
2519 >    }}
2520  
2521      // other static methods
2522  
# Line 3418 | Line 2718 | public class CompletableFutureTest exten
2718       */
2719      public void testWhenComplete_normalCompletion1() {
2720          for (ExecutionMode m : ExecutionMode.values())
2721 <        for (Integer v1 : new Integer[] { 1, null }) {
2722 <
2723 <        final AtomicInteger a = new AtomicInteger();
2721 >        for (boolean createIncomplete : new boolean[] { true, false })
2722 >        for (Integer v1 : new Integer[] { 1, null })
2723 >    {
2724 >        final AtomicInteger a = new AtomicInteger(0);
2725          final CompletableFuture<Integer> f = new CompletableFuture<>();
2726 <        final CompletableFuture<Integer> g =
2727 <            m.whenComplete(f,
2728 <                           (Integer x, Throwable t) -> {
2729 <                               threadAssertSame(x, v1);
2730 <                               threadAssertNull(t);
2731 <                               a.getAndIncrement();
2732 <                           });
2733 <        f.complete(v1);
2734 <        checkCompletedNormally(f, v1);
2726 >        if (!createIncomplete) f.complete(v1);
2727 >        final CompletableFuture<Integer> g = m.whenComplete
2728 >            (f,
2729 >             (Integer x, Throwable t) -> {
2730 >                threadAssertSame(x, v1);
2731 >                threadAssertNull(t);
2732 >                a.getAndIncrement();
2733 >            });
2734 >        if (createIncomplete) f.complete(v1);
2735 >
2736          checkCompletedNormally(g, v1);
2737 <        assertEquals(a.get(), 1);
2738 <        }
2739 <    }
2737 >        checkCompletedNormally(f, v1);
2738 >        assertEquals(1, a.get());
2739 >    }}
2740  
2741      /**
2742       * whenComplete action executes on exceptional completion, propagating
# Line 3442 | Line 2744 | public class CompletableFutureTest exten
2744       */
2745      public void testWhenComplete_exceptionalCompletion() {
2746          for (ExecutionMode m : ExecutionMode.values())
2747 <        for (Integer v1 : new Integer[] { 1, null }) {
2748 <
2749 <        final AtomicInteger a = new AtomicInteger();
2747 >        for (boolean createIncomplete : new boolean[] { true, false })
2748 >        for (Integer v1 : new Integer[] { 1, null })
2749 >    {
2750 >        final AtomicInteger a = new AtomicInteger(0);
2751          final CFException ex = new CFException();
2752          final CompletableFuture<Integer> f = new CompletableFuture<>();
2753 +        if (!createIncomplete) f.completeExceptionally(ex);
2754          final CompletableFuture<Integer> g = m.whenComplete
2755              (f,
2756               (Integer x, Throwable t) -> {
# Line 3454 | Line 2758 | public class CompletableFutureTest exten
2758                  threadAssertSame(t, ex);
2759                  a.getAndIncrement();
2760              });
2761 <        f.completeExceptionally(ex);
2761 >        if (createIncomplete) f.completeExceptionally(ex);
2762          checkCompletedWithWrappedCFException(f, ex);
2763          checkCompletedWithWrappedCFException(g, ex);
2764 <        assertEquals(a.get(), 1);
2765 <        }
2766 <    }
2764 >        assertEquals(1, a.get());
2765 >    }}
2766 >
2767 >    /**
2768 >     * whenComplete action executes on cancelled source, propagating
2769 >     * CancellationException.
2770 >     */
2771 >    public void testWhenComplete_sourceCancelled() {
2772 >        for (ExecutionMode m : ExecutionMode.values())
2773 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2774 >        for (boolean createIncomplete : new boolean[] { true, false })
2775 >    {
2776 >        final AtomicInteger a = new AtomicInteger(0);
2777 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2778 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2779 >        final CompletableFuture<Integer> g = m.whenComplete
2780 >            (f,
2781 >             (Integer x, Throwable t) -> {
2782 >                threadAssertNull(x);
2783 >                threadAssertTrue(t instanceof CancellationException);
2784 >                a.getAndIncrement();
2785 >            });
2786 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2787 >
2788 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
2789 >        checkCompletedWithWrappedCancellationException(g);
2790 >        checkCancelled(f);
2791 >        assertEquals(1, a.get());
2792 >    }}
2793  
2794      /**
2795       * If a whenComplete action throws an exception when triggered by
2796       * a normal completion, it completes exceptionally
2797       */
2798      public void testWhenComplete_actionFailed() {
2799 +        for (boolean createIncomplete : new boolean[] { true, false })
2800          for (ExecutionMode m : ExecutionMode.values())
2801 <        for (Integer v1 : new Integer[] { 1, null }) {
2802 <
2801 >        for (Integer v1 : new Integer[] { 1, null })
2802 >    {
2803 >        final AtomicInteger a = new AtomicInteger(0);
2804          final CFException ex = new CFException();
2805          final CompletableFuture<Integer> f = new CompletableFuture<>();
2806 +        if (!createIncomplete) f.complete(v1);
2807          final CompletableFuture<Integer> g = m.whenComplete
2808              (f,
2809               (Integer x, Throwable t) -> {
2810                  threadAssertSame(x, v1);
2811                  threadAssertNull(t);
2812 +                a.getAndIncrement();
2813                  throw ex;
2814              });
2815 <        f.complete(v1);
2815 >        if (createIncomplete) f.complete(v1);
2816          checkCompletedNormally(f, v1);
2817          checkCompletedWithWrappedCFException(g, ex);
2818 <        }
2819 <    }
2818 >        assertEquals(1, a.get());
2819 >    }}
2820  
2821      /**
2822       * If a whenComplete action throws an exception when triggered by
# Line 3490 | Line 2824 | public class CompletableFutureTest exten
2824       * exception takes precedence.
2825       */
2826      public void testWhenComplete_actionFailedSourceFailed() {
2827 +        for (boolean createIncomplete : new boolean[] { true, false })
2828          for (ExecutionMode m : ExecutionMode.values())
2829 <        for (Integer v1 : new Integer[] { 1, null }) {
2830 <
2829 >        for (Integer v1 : new Integer[] { 1, null })
2830 >    {
2831 >        final AtomicInteger a = new AtomicInteger(0);
2832          final CFException ex1 = new CFException();
2833          final CFException ex2 = new CFException();
2834          final CompletableFuture<Integer> f = new CompletableFuture<>();
2835 +
2836 +        if (!createIncomplete) f.completeExceptionally(ex1);
2837          final CompletableFuture<Integer> g = m.whenComplete
2838              (f,
2839               (Integer x, Throwable t) -> {
2840                  threadAssertSame(t, ex1);
2841                  threadAssertNull(x);
2842 +                a.getAndIncrement();
2843                  throw ex2;
2844              });
2845 <        f.completeExceptionally(ex1);
2845 >        if (createIncomplete) f.completeExceptionally(ex1);
2846 >
2847          checkCompletedWithWrappedCFException(f, ex1);
2848          checkCompletedWithWrappedCFException(g, ex1);
2849 <        }
2850 <    }
3511 <
3512 <    /**
3513 <     * handleAsync action completes normally with function value on
3514 <     * either normal or exceptional completion of source
3515 <     */
3516 <    public void testHandleAsync() {
3517 <        CompletableFuture<Integer> f, g;
3518 <        IntegerHandler r;
3519 <
3520 <        f = new CompletableFuture<>();
3521 <        g = f.handleAsync(r = new IntegerHandler());
3522 <        assertFalse(r.ran);
3523 <        f.completeExceptionally(new CFException());
3524 <        checkCompletedWithWrappedCFException(f);
3525 <        checkCompletedNormally(g, three);
3526 <        assertTrue(r.ran);
3527 <
3528 <        f = new CompletableFuture<>();
3529 <        g = f.handleAsync(r = new IntegerHandler());
3530 <        assertFalse(r.ran);
3531 <        f.completeExceptionally(new CFException());
3532 <        checkCompletedWithWrappedCFException(f);
3533 <        checkCompletedNormally(g, three);
3534 <        assertTrue(r.ran);
3535 <
3536 <        f = new CompletableFuture<>();
3537 <        g = f.handleAsync(r = new IntegerHandler());
3538 <        assertFalse(r.ran);
3539 <        f.complete(one);
3540 <        checkCompletedNormally(f, one);
3541 <        checkCompletedNormally(g, two);
3542 <        assertTrue(r.ran);
3543 <
3544 <        f = new CompletableFuture<>();
3545 <        g = f.handleAsync(r = new IntegerHandler());
3546 <        assertFalse(r.ran);
3547 <        f.complete(one);
3548 <        checkCompletedNormally(f, one);
3549 <        checkCompletedNormally(g, two);
3550 <        assertTrue(r.ran);
3551 <    }
3552 <
3553 <    /**
3554 <     * handleAsync action with Executor completes normally with
3555 <     * function value on either normal or exceptional completion of
3556 <     * source
3557 <     */
3558 <    public void testHandleAsync2() {
3559 <        CompletableFuture<Integer> f, g;
3560 <        ThreadExecutor exec = new ThreadExecutor();
3561 <        IntegerHandler r;
3562 <
3563 <        f = new CompletableFuture<>();
3564 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3565 <        assertFalse(r.ran);
3566 <        f.completeExceptionally(new CFException());
3567 <        checkCompletedWithWrappedCFException(f);
3568 <        checkCompletedNormally(g, three);
3569 <        assertTrue(r.ran);
3570 <
3571 <        f = new CompletableFuture<>();
3572 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3573 <        assertFalse(r.ran);
3574 <        f.completeExceptionally(new CFException());
3575 <        checkCompletedWithWrappedCFException(f);
3576 <        checkCompletedNormally(g, three);
3577 <        assertTrue(r.ran);
3578 <
3579 <        f = new CompletableFuture<>();
3580 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3581 <        assertFalse(r.ran);
3582 <        f.complete(one);
3583 <        checkCompletedNormally(f, one);
3584 <        checkCompletedNormally(g, two);
3585 <        assertTrue(r.ran);
3586 <
3587 <        f = new CompletableFuture<>();
3588 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3589 <        assertFalse(r.ran);
3590 <        f.complete(one);
3591 <        checkCompletedNormally(f, one);
3592 <        checkCompletedNormally(g, two);
3593 <        assertTrue(r.ran);
3594 <    }
2849 >        assertEquals(1, a.get());
2850 >    }}
2851  
2852   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines