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.40 by jsr166, Mon Jun 2 01:11:53 2014 UTC vs.
Revision 1.52 by jsr166, Mon Jun 2 20:10:04 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);
375          }
376      }
377      static final class Noop implements Runnable {
378 <        boolean ran;
379 <        public void run() { ran = true; }
378 >        int invocationCount = 0;
379 >        public void run() {
380 >            invocationCount++;
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 433 | Line 454 | public class CompletableFutureTest exten
454          }
455      }
456  
436    static final class ExceptionToInteger implements Function<Throwable, Integer> {
437        public Integer apply(Throwable x) { return Integer.valueOf(3); }
438    }
439
440    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
441        boolean ran;
442        public Integer apply(Integer x, Throwable t) {
443            ran = true;
444            return (t == null) ? two : three;
445        }
446    }
447
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 467 | 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 479 | 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              }
498        },
499
500 //             /** Experimental way to do more testing */
501 //         REVERSE_DEFAULT {
502 //             public <T,U> CompletableFuture<Void> runAfterBoth
503 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
504 //                 return g.runAfterBoth(f, a);
505 //             }
506 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
507 //                 (CompletableFuture<T> f,
508 //                  CompletionStage<? extends U> g,
509 //                  BiConsumer<? super T,? super U> a) {
510 //                 return DEFAULT.thenAcceptBoth(f, g, a);
511 //             }
512 //         },
513
514        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 528 | 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 540 | 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              }
559        },
560
561 //         REVERSE_DEFAULT_ASYNC {
562 //             public <T,U> CompletableFuture<Void> runAfterBoth
563 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
564 //                 return f.runAfterBothAsync(g, a);
565 //             }
566 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
567 //                 (CompletableFuture<T> f,
568 //                  CompletionStage<? extends U> g,
569 //                  BiConsumer<? super T,? super U> a) {
570 //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
571 //             }
572 //         },
573
574        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 588 | Line 641 | public class CompletableFutureTest exten
641                   BiFunction<? super T,? super U,? extends V> a) {
642                  return f.thenCombineAsync(g, a, new ThreadExecutor());
643              }
591            public <T,U> CompletableFuture<U> applyToEither
592                (CompletableFuture<T> f,
593                 CompletionStage<? extends T> g,
594                 Function<? super T,U> a) {
595                return f.applyToEitherAsync(g, a, new ThreadExecutor());
596            }
597            public <T> CompletableFuture<Void> acceptEither
598                (CompletableFuture<T> f,
599                 CompletionStage<? extends T> g,
600                 Consumer<? super T> a) {
601                return f.acceptEitherAsync(g, a, new ThreadExecutor());
602            }
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 628 | Line 687 | public class CompletableFutureTest exten
687              (CompletableFuture<T> f,
688               CompletionStage<? extends U> g,
689               BiFunction<? super T,? super U,? extends V> a);
631        public abstract <T,U> CompletableFuture<U> applyToEither
632            (CompletableFuture<T> f,
633             CompletionStage<? extends T> g,
634             Function<? super T,U> a);
635        public abstract <T> CompletableFuture<Void> acceptEither
636            (CompletableFuture<T> f,
637             CompletionStage<? extends T> g,
638             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  
651    }
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);
683 <        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);
696 <        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 710 | 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 722 | 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 731 | 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 764 | 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 772 | 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  
786        f = new CompletableFuture<>();
787        f.complete(null);
788        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);
812 <        assertFalse(r.ran);
813 <    }
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);
832 <    }
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());
850 <        checkCompletedWithWrappedCancellationException(g);
851 <    }
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() {
878 <        CompletableFuture<Integer> f = new CompletableFuture<>();
879 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
880 <        f.complete(one);
881 <        checkCompletedWithWrappedCFException(g);
882 <    }
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 <     * thenAccept result completes normally after normal completion of source
1130 >     * thenApply result completes exceptionally if action does
1131       */
1132 <    public void testThenAccept() {
1133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1134 <        IncAction r = new IncAction();
1135 <        CompletableFuture<Void> g = f.thenAccept(r);
1136 <        f.complete(one);
1137 <        checkCompletedNormally(g, null);
1138 <        assertEquals(r.value, (Integer) 2);
1139 <    }
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  
906    /**
907     * thenAccept result completes exceptionally after exceptional
908     * completion of source
909     */
910    public void testThenAccept2() {
911        CompletableFuture<Integer> f = new CompletableFuture<>();
912        IncAction r = new IncAction();
913        CompletableFuture<Void> g = f.thenAccept(r);
914        f.completeExceptionally(new CFException());
1146          checkCompletedWithWrappedCFException(g);
1147 <    }
1147 >        checkCompletedNormally(f, v1);
1148 >    }}
1149  
1150      /**
1151 <     * thenAccept result completes exceptionally if action does
1151 >     * thenAccept result completes normally after normal completion of source
1152       */
1153 <    public void testThenAccept3() {
1154 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1155 <        FailingConsumer r = new FailingConsumer();
1156 <        CompletableFuture<Void> g = f.thenAccept(r);
1157 <        f.complete(one);
1158 <        checkCompletedWithWrappedCFException(g);
1159 <        assertTrue(r.ran);
1160 <    }
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 <    /**
1168 <     * thenAccept result completes exceptionally if source cancelled
1169 <     */
1170 <    public void testThenAccept4() {
1171 <        CompletableFuture<Integer> f = new CompletableFuture<>();
935 <        IncAction r = new IncAction();
936 <        CompletableFuture<Void> g = f.thenAccept(r);
937 <        assertTrue(f.cancel(true));
938 <        checkCompletedWithWrappedCancellationException(g);
939 <    }
1167 >        checkCompletedNormally(g, null);
1168 >        checkCompletedNormally(f, v1);
1169 >        assertEquals(1, r.invocationCount);
1170 >        assertEquals(inc(v1), r.value);
1171 >    }}
1172  
1173      /**
1174 <     * thenCombine result completes normally after normal completion
1175 <     * of sources
1174 >     * thenAccept result completes exceptionally after exceptional
1175 >     * completion of source
1176       */
1177 <    public void testThenCombine_normalCompletion1() {
1177 >    public void testThenAccept_exceptionalCompletion() {
1178          for (ExecutionMode m : ExecutionMode.values())
1179 <        for (Integer v1 : new Integer[] { 1, null })
1180 <        for (Integer v2 : new Integer[] { 2, null }) {
1181 <
1179 >        for (boolean createIncomplete : new boolean[] { true, false })
1180 >    {
1181 >        final CFException ex = new CFException();
1182          final CompletableFuture<Integer> f = new CompletableFuture<>();
1183 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1184 <        final SubtractFunction r = new SubtractFunction();
1185 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1186 <
1187 <        f.complete(v1);
1188 <        checkIncomplete(h);
957 <        assertFalse(r.ran());
958 <        g.complete(v2);
959 <
960 <        checkCompletedNormally(h, subtract(v1, v2));
961 <        checkCompletedNormally(f, v1);
962 <        checkCompletedNormally(g, v2);
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          }
964    }
1190  
1191 <    public void testThenCombine_normalCompletion2() {
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 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 <        for (Integer v2 : new Integer[] { 2, null }) {
970 <
1203 >    {
1204          final CompletableFuture<Integer> f = new CompletableFuture<>();
1205 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1206 <        final SubtractFunction r = new SubtractFunction();
1207 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1208 <
1209 <        g.complete(v2);
1210 <        checkIncomplete(h);
1211 <        assertFalse(r.ran());
979 <        f.complete(v1);
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 <        checkCompletedNormally(h, subtract(v1, v2));
1213 >        checkCompletedWithWrappedCFException(g);
1214          checkCompletedNormally(f, v1);
1215 <        checkCompletedNormally(g, v2);
984 <        }
985 <    }
1215 >    }}
1216  
1217 <    public void testThenCombine_normalCompletion3() {
1217 >    /**
1218 >     * thenAccept result completes exceptionally if source cancelled
1219 >     */
1220 >    public void testThenAccept_sourceCancelled() {
1221          for (ExecutionMode m : ExecutionMode.values())
1222 <        for (Integer v1 : new Integer[] { 1, null })
1223 <        for (Integer v2 : new Integer[] { 2, null }) {
1224 <
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 CompletableFuture<Integer> g = new CompletableFuture<>();
1227 <        final SubtractFunction r = new SubtractFunction();
1228 <
1229 <        g.complete(v2);
1230 <        f.complete(v1);
1231 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
999 <
1000 <        checkCompletedNormally(h, subtract(v1, v2));
1001 <        checkCompletedNormally(f, v1);
1002 <        checkCompletedNormally(g, v2);
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          }
1004    }
1233  
1234 <    public void testThenCombine_normalCompletion4() {
1234 >        checkCompletedWithWrappedCancellationException(g);
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_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();
1253  
1254 <        f.complete(v1);
1255 <        g.complete(v2);
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 <        }
1268 <    }
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() {
1030 <        for (ExecutionMode m : ExecutionMode.values())
1031 <        for (Integer v1 : new Integer[] { 1, null }) {
1032 <
1033 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1034 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1035 <        final SubtractFunction r = new SubtractFunction();
1036 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1037 <        final CFException ex = new CFException();
1038 <
1039 <        f.completeExceptionally(ex);
1040 <        checkIncomplete(h);
1041 <        g.complete(v1);
1042 <
1043 <        checkCompletedWithWrappedCFException(h, ex);
1044 <        checkCompletedWithWrappedCFException(f, ex);
1045 <        assertFalse(r.ran());
1046 <        checkCompletedNormally(g, v1);
1047 <        }
1048 <    }
1049 <
1050 <    public void testThenCombine_exceptionalCompletion2() {
1274 >    public void testThenCombine_exceptionalCompletion() {
1275          for (ExecutionMode m : ExecutionMode.values())
1276 <        for (Integer v1 : new Integer[] { 1, null }) {
1277 <
1276 >        for (boolean createIncomplete : new boolean[] { true, false })
1277 >        for (boolean fFirst : new boolean[] { true, false })
1278 >        for (Integer v1 : new Integer[] { 1, null })
1279 >    {
1280          final CompletableFuture<Integer> f = new CompletableFuture<>();
1281          final CompletableFuture<Integer> g = new CompletableFuture<>();
1056        final SubtractFunction r = new SubtractFunction();
1057        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1282          final CFException ex = new CFException();
1059
1060        g.completeExceptionally(ex);
1061        checkIncomplete(h);
1062        f.complete(v1);
1063
1064        checkCompletedWithWrappedCFException(h, ex);
1065        checkCompletedWithWrappedCFException(g, ex);
1066        assertFalse(r.ran());
1067        checkCompletedNormally(f, v1);
1068        }
1069    }
1070
1071    public void testThenCombine_exceptionalCompletion3() {
1072        for (ExecutionMode m : ExecutionMode.values())
1073        for (Integer v1 : new Integer[] { 1, null }) {
1074
1075        final CompletableFuture<Integer> f = new CompletableFuture<>();
1076        final CompletableFuture<Integer> g = new CompletableFuture<>();
1283          final SubtractFunction r = new SubtractFunction();
1078        final CFException ex = new CFException();
1284  
1285 <        g.completeExceptionally(ex);
1286 <        f.complete(v1);
1285 >        (fFirst ? f : g).complete(v1);
1286 >        if (!createIncomplete)
1287 >            (!fFirst ? f : g).completeExceptionally(ex);
1288          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1289 <
1290 <        checkCompletedWithWrappedCFException(h, ex);
1291 <        checkCompletedWithWrappedCFException(g, ex);
1086 <        assertFalse(r.ran());
1087 <        checkCompletedNormally(f, v1);
1289 >        if (createIncomplete) {
1290 >            checkIncomplete(h);
1291 >            (!fFirst ? f : g).completeExceptionally(ex);
1292          }
1089    }
1090
1091    public void testThenCombine_exceptionalCompletion4() {
1092        for (ExecutionMode m : ExecutionMode.values())
1093        for (Integer v1 : new Integer[] { 1, null }) {
1094
1095        final CompletableFuture<Integer> f = new CompletableFuture<>();
1096        final CompletableFuture<Integer> g = new CompletableFuture<>();
1097        final SubtractFunction r = new SubtractFunction();
1098        final CFException ex = new CFException();
1099
1100        f.completeExceptionally(ex);
1101        g.complete(v1);
1102        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1293  
1294          checkCompletedWithWrappedCFException(h, ex);
1295 <        checkCompletedWithWrappedCFException(f, ex);
1296 <        assertFalse(r.ran());
1297 <        checkCompletedNormally(g, v1);
1298 <        }
1109 <    }
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);
1130 <        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          }
1132    }
1133
1134    public void testThenCombine_actionFailed2() {
1135        for (ExecutionMode m : ExecutionMode.values())
1136        for (Integer v1 : new Integer[] { 1, null })
1137        for (Integer v2 : new Integer[] { 2, null }) {
1138
1139        final CompletableFuture<Integer> f = new CompletableFuture<>();
1140        final CompletableFuture<Integer> g = new CompletableFuture<>();
1141        final FailingBiFunction r = new FailingBiFunction();
1142        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1143
1144        g.complete(v2);
1145        checkIncomplete(h);
1146        f.complete(v1);
1321  
1322          checkCompletedWithWrappedCFException(h);
1323          checkCompletedNormally(f, v1);
1324          checkCompletedNormally(g, v2);
1325 <        }
1152 <    }
1325 >    }}
1326  
1327      /**
1328       * thenCombine result completes exceptionally if either source cancelled
1329       */
1330 <    public void testThenCombine_sourceCancelled1() {
1158 <        for (ExecutionMode m : ExecutionMode.values())
1159 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1160 <        for (Integer v1 : new Integer[] { 1, null }) {
1161 <
1162 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1163 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1164 <        final SubtractFunction r = new SubtractFunction();
1165 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1166 <
1167 <        assertTrue(f.cancel(mayInterruptIfRunning));
1168 <        checkIncomplete(h);
1169 <        g.complete(v1);
1170 <
1171 <        checkCompletedWithWrappedCancellationException(h);
1172 <        checkCancelled(f);
1173 <        assertFalse(r.ran());
1174 <        checkCompletedNormally(g, v1);
1175 <        }
1176 <    }
1177 <
1178 <    public void testThenCombine_sourceCancelled2() {
1179 <        for (ExecutionMode m : ExecutionMode.values())
1180 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1181 <        for (Integer v1 : new Integer[] { 1, null }) {
1182 <
1183 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1184 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1185 <        final SubtractFunction r = new SubtractFunction();
1186 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1187 <
1188 <        assertTrue(g.cancel(mayInterruptIfRunning));
1189 <        checkIncomplete(h);
1190 <        f.complete(v1);
1191 <
1192 <        checkCompletedWithWrappedCancellationException(h);
1193 <        checkCancelled(g);
1194 <        assertFalse(r.ran());
1195 <        checkCompletedNormally(f, v1);
1196 <        }
1197 <    }
1198 <
1199 <    public void testThenCombine_sourceCancelled3() {
1330 >    public void testThenCombine_sourceCancelled() {
1331          for (ExecutionMode m : ExecutionMode.values())
1332          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1333 <        for (Integer v1 : new Integer[] { 1, null }) {
1334 <
1333 >        for (boolean createIncomplete : new boolean[] { true, false })
1334 >        for (boolean fFirst : new boolean[] { true, false })
1335 >        for (Integer v1 : new Integer[] { 1, null })
1336 >    {
1337          final CompletableFuture<Integer> f = new CompletableFuture<>();
1338          final CompletableFuture<Integer> g = new CompletableFuture<>();
1339          final SubtractFunction r = new SubtractFunction();
1340  
1341 <        assertTrue(g.cancel(mayInterruptIfRunning));
1342 <        f.complete(v1);
1341 >        (fFirst ? f : g).complete(v1);
1342 >        if (!createIncomplete)
1343 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1344          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1345 <
1346 <        checkCompletedWithWrappedCancellationException(h);
1347 <        checkCancelled(g);
1214 <        assertFalse(r.ran());
1215 <        checkCompletedNormally(f, v1);
1345 >        if (createIncomplete) {
1346 >            checkIncomplete(h);
1347 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1348          }
1217    }
1218
1219    public void testThenCombine_sourceCancelled4() {
1220        for (ExecutionMode m : ExecutionMode.values())
1221        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1222        for (Integer v1 : new Integer[] { 1, null }) {
1223
1224        final CompletableFuture<Integer> f = new CompletableFuture<>();
1225        final CompletableFuture<Integer> g = new CompletableFuture<>();
1226        final SubtractFunction r = new SubtractFunction();
1227
1228        assertTrue(f.cancel(mayInterruptIfRunning));
1229        g.complete(v1);
1230        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1349  
1350          checkCompletedWithWrappedCancellationException(h);
1351 <        checkCancelled(f);
1352 <        assertFalse(r.ran());
1353 <        checkCompletedNormally(g, v1);
1354 <        }
1237 <    }
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
# Line 1243 | Line 1360 | public class CompletableFutureTest exten
1360      public void testThenAcceptBoth_normalCompletion1() {
1361          for (ExecutionMode m : ExecutionMode.values())
1362          for (Integer v1 : new Integer[] { 1, null })
1363 <        for (Integer v2 : new Integer[] { 2, null }) {
1364 <
1363 >        for (Integer v2 : new Integer[] { 2, null })
1364 >    {
1365          final CompletableFuture<Integer> f = new CompletableFuture<>();
1366          final CompletableFuture<Integer> g = new CompletableFuture<>();
1367          final SubtractAction r = new SubtractAction();
# Line 1252 | Line 1369 | public class CompletableFutureTest exten
1369  
1370          f.complete(v1);
1371          checkIncomplete(h);
1372 <        assertFalse(r.ran());
1372 >        assertEquals(0, r.invocationCount);
1373          g.complete(v2);
1374  
1375          checkCompletedNormally(h, null);
1376 <        assertEquals(r.value, subtract(v1, v2));
1376 >        assertEquals(subtract(v1, v2), r.value);
1377          checkCompletedNormally(f, v1);
1378          checkCompletedNormally(g, v2);
1379 <        }
1263 <    }
1379 >    }}
1380  
1381      public void testThenAcceptBoth_normalCompletion2() {
1382          for (ExecutionMode m : ExecutionMode.values())
1383          for (Integer v1 : new Integer[] { 1, null })
1384 <        for (Integer v2 : new Integer[] { 2, null }) {
1385 <
1384 >        for (Integer v2 : new Integer[] { 2, null })
1385 >    {
1386          final CompletableFuture<Integer> f = new CompletableFuture<>();
1387          final CompletableFuture<Integer> g = new CompletableFuture<>();
1388          final SubtractAction r = new SubtractAction();
# Line 1274 | Line 1390 | public class CompletableFutureTest exten
1390  
1391          g.complete(v2);
1392          checkIncomplete(h);
1393 <        assertFalse(r.ran());
1393 >        assertEquals(0, r.invocationCount);
1394          f.complete(v1);
1395  
1396          checkCompletedNormally(h, null);
1397 <        assertEquals(r.value, subtract(v1, v2));
1397 >        assertEquals(subtract(v1, v2), r.value);
1398          checkCompletedNormally(f, v1);
1399          checkCompletedNormally(g, v2);
1400 <        }
1285 <    }
1400 >    }}
1401  
1402      public void testThenAcceptBoth_normalCompletion3() {
1403          for (ExecutionMode m : ExecutionMode.values())
1404          for (Integer v1 : new Integer[] { 1, null })
1405 <        for (Integer v2 : new Integer[] { 2, null }) {
1406 <
1405 >        for (Integer v2 : new Integer[] { 2, null })
1406 >    {
1407          final CompletableFuture<Integer> f = new CompletableFuture<>();
1408          final CompletableFuture<Integer> g = new CompletableFuture<>();
1409          final SubtractAction r = new SubtractAction();
# Line 1298 | Line 1413 | public class CompletableFutureTest exten
1413          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1414  
1415          checkCompletedNormally(h, null);
1416 <        assertEquals(r.value, subtract(v1, v2));
1416 >        assertEquals(subtract(v1, v2), r.value);
1417          checkCompletedNormally(f, v1);
1418          checkCompletedNormally(g, v2);
1419 <        }
1305 <    }
1419 >    }}
1420  
1421      public void testThenAcceptBoth_normalCompletion4() {
1422          for (ExecutionMode m : ExecutionMode.values())
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 SubtractAction r = new SubtractAction();
# Line 1318 | Line 1432 | public class CompletableFutureTest exten
1432          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1433  
1434          checkCompletedNormally(h, null);
1435 <        assertEquals(r.value, subtract(v1, v2));
1435 >        assertEquals(subtract(v1, v2), r.value);
1436          checkCompletedNormally(f, v1);
1437          checkCompletedNormally(g, v2);
1438 <        }
1325 <    }
1438 >    }}
1439  
1440      /**
1441       * thenAcceptBoth result completes exceptionally after exceptional
# Line 1330 | Line 1443 | public class CompletableFutureTest exten
1443       */
1444      public void testThenAcceptBoth_exceptionalCompletion1() {
1445          for (ExecutionMode m : ExecutionMode.values())
1446 <        for (Integer v1 : new Integer[] { 1, null }) {
1447 <
1446 >        for (Integer v1 : new Integer[] { 1, null })
1447 >    {
1448          final CompletableFuture<Integer> f = new CompletableFuture<>();
1449          final CompletableFuture<Integer> g = new CompletableFuture<>();
1450          final SubtractAction r = new SubtractAction();
# Line 1344 | Line 1457 | public class CompletableFutureTest exten
1457  
1458          checkCompletedWithWrappedCFException(h, ex);
1459          checkCompletedWithWrappedCFException(f, ex);
1460 <        assertFalse(r.ran());
1460 >        assertEquals(0, r.invocationCount);
1461          checkCompletedNormally(g, v1);
1462 <        }
1350 <    }
1462 >    }}
1463  
1464      public void testThenAcceptBoth_exceptionalCompletion2() {
1465          for (ExecutionMode m : ExecutionMode.values())
1466 <        for (Integer v1 : new Integer[] { 1, null }) {
1467 <
1466 >        for (Integer v1 : new Integer[] { 1, null })
1467 >    {
1468          final CompletableFuture<Integer> f = new CompletableFuture<>();
1469          final CompletableFuture<Integer> g = new CompletableFuture<>();
1470          final SubtractAction r = new SubtractAction();
# Line 1365 | Line 1477 | public class CompletableFutureTest exten
1477  
1478          checkCompletedWithWrappedCFException(h, ex);
1479          checkCompletedWithWrappedCFException(g, ex);
1480 <        assertFalse(r.ran());
1480 >        assertEquals(0, r.invocationCount);
1481          checkCompletedNormally(f, v1);
1482 <        }
1371 <    }
1482 >    }}
1483  
1484      public void testThenAcceptBoth_exceptionalCompletion3() {
1485          for (ExecutionMode m : ExecutionMode.values())
1486 <        for (Integer v1 : new Integer[] { 1, null }) {
1487 <
1486 >        for (Integer v1 : new Integer[] { 1, null })
1487 >    {
1488          final CompletableFuture<Integer> f = new CompletableFuture<>();
1489          final CompletableFuture<Integer> g = new CompletableFuture<>();
1490          final SubtractAction r = new SubtractAction();
# Line 1385 | Line 1496 | public class CompletableFutureTest exten
1496  
1497          checkCompletedWithWrappedCFException(h, ex);
1498          checkCompletedWithWrappedCFException(g, ex);
1499 <        assertFalse(r.ran());
1499 >        assertEquals(0, r.invocationCount);
1500          checkCompletedNormally(f, v1);
1501 <        }
1391 <    }
1501 >    }}
1502  
1503      public void testThenAcceptBoth_exceptionalCompletion4() {
1504          for (ExecutionMode m : ExecutionMode.values())
1505 <        for (Integer v1 : new Integer[] { 1, null }) {
1506 <
1505 >        for (Integer v1 : new Integer[] { 1, null })
1506 >    {
1507          final CompletableFuture<Integer> f = new CompletableFuture<>();
1508          final CompletableFuture<Integer> g = new CompletableFuture<>();
1509          final SubtractAction r = new SubtractAction();
# Line 1405 | Line 1515 | public class CompletableFutureTest exten
1515  
1516          checkCompletedWithWrappedCFException(h, ex);
1517          checkCompletedWithWrappedCFException(f, ex);
1518 <        assertFalse(r.ran());
1518 >        assertEquals(0, r.invocationCount);
1519          checkCompletedNormally(g, v1);
1520 <        }
1411 <    }
1520 >    }}
1521  
1522      /**
1523       * thenAcceptBoth result completes exceptionally if action does
# Line 1416 | Line 1525 | public class CompletableFutureTest exten
1525      public void testThenAcceptBoth_actionFailed1() {
1526          for (ExecutionMode m : ExecutionMode.values())
1527          for (Integer v1 : new Integer[] { 1, null })
1528 <        for (Integer v2 : new Integer[] { 2, null }) {
1529 <
1528 >        for (Integer v2 : new Integer[] { 2, null })
1529 >    {
1530          final CompletableFuture<Integer> f = new CompletableFuture<>();
1531          final CompletableFuture<Integer> g = new CompletableFuture<>();
1532          final FailingBiConsumer r = new FailingBiConsumer();
# Line 1430 | Line 1539 | public class CompletableFutureTest exten
1539          checkCompletedWithWrappedCFException(h);
1540          checkCompletedNormally(f, v1);
1541          checkCompletedNormally(g, v2);
1542 <        }
1434 <    }
1542 >    }}
1543  
1544      public void testThenAcceptBoth_actionFailed2() {
1545          for (ExecutionMode m : ExecutionMode.values())
1546          for (Integer v1 : new Integer[] { 1, null })
1547 <        for (Integer v2 : new Integer[] { 2, null }) {
1548 <
1547 >        for (Integer v2 : new Integer[] { 2, null })
1548 >    {
1549          final CompletableFuture<Integer> f = new CompletableFuture<>();
1550          final CompletableFuture<Integer> g = new CompletableFuture<>();
1551          final FailingBiConsumer r = new FailingBiConsumer();
# Line 1450 | Line 1558 | public class CompletableFutureTest exten
1558          checkCompletedWithWrappedCFException(h);
1559          checkCompletedNormally(f, v1);
1560          checkCompletedNormally(g, v2);
1561 <        }
1454 <    }
1561 >    }}
1562  
1563      /**
1564       * thenAcceptBoth result completes exceptionally if either source cancelled
# Line 1459 | Line 1566 | public class CompletableFutureTest exten
1566      public void testThenAcceptBoth_sourceCancelled1() {
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 (Integer v1 : new Integer[] { 1, null })
1570 >    {
1571          final CompletableFuture<Integer> f = new CompletableFuture<>();
1572          final CompletableFuture<Integer> g = new CompletableFuture<>();
1573          final SubtractAction r = new SubtractAction();
# Line 1472 | Line 1579 | public class CompletableFutureTest exten
1579  
1580          checkCompletedWithWrappedCancellationException(h);
1581          checkCancelled(f);
1582 <        assertFalse(r.ran());
1582 >        assertEquals(0, r.invocationCount);
1583          checkCompletedNormally(g, v1);
1584 <        }
1478 <    }
1584 >    }}
1585  
1586      public void testThenAcceptBoth_sourceCancelled2() {
1587          for (ExecutionMode m : ExecutionMode.values())
1588          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1589 <        for (Integer v1 : new Integer[] { 1, null }) {
1590 <
1589 >        for (Integer v1 : new Integer[] { 1, null })
1590 >    {
1591          final CompletableFuture<Integer> f = new CompletableFuture<>();
1592          final CompletableFuture<Integer> g = new CompletableFuture<>();
1593          final SubtractAction r = new SubtractAction();
# Line 1493 | Line 1599 | public class CompletableFutureTest exten
1599  
1600          checkCompletedWithWrappedCancellationException(h);
1601          checkCancelled(g);
1602 <        assertFalse(r.ran());
1602 >        assertEquals(0, r.invocationCount);
1603          checkCompletedNormally(f, v1);
1604 <        }
1499 <    }
1604 >    }}
1605  
1606      public void testThenAcceptBoth_sourceCancelled3() {
1607          for (ExecutionMode m : ExecutionMode.values())
1608          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1609 <        for (Integer v1 : new Integer[] { 1, null }) {
1610 <
1609 >        for (Integer v1 : new Integer[] { 1, null })
1610 >    {
1611          final CompletableFuture<Integer> f = new CompletableFuture<>();
1612          final CompletableFuture<Integer> g = new CompletableFuture<>();
1613          final SubtractAction r = new SubtractAction();
# Line 1513 | Line 1618 | public class CompletableFutureTest exten
1618  
1619          checkCompletedWithWrappedCancellationException(h);
1620          checkCancelled(g);
1621 <        assertFalse(r.ran());
1621 >        assertEquals(0, r.invocationCount);
1622          checkCompletedNormally(f, v1);
1623 <        }
1519 <    }
1623 >    }}
1624  
1625      public void testThenAcceptBoth_sourceCancelled4() {
1626          for (ExecutionMode m : ExecutionMode.values())
1627          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1628 <        for (Integer v1 : new Integer[] { 1, null }) {
1629 <
1628 >        for (Integer v1 : new Integer[] { 1, null })
1629 >    {
1630          final CompletableFuture<Integer> f = new CompletableFuture<>();
1631          final CompletableFuture<Integer> g = new CompletableFuture<>();
1632          final SubtractAction r = new SubtractAction();
# Line 1533 | Line 1637 | public class CompletableFutureTest exten
1637  
1638          checkCompletedWithWrappedCancellationException(h);
1639          checkCancelled(f);
1640 <        assertFalse(r.ran());
1640 >        assertEquals(0, r.invocationCount);
1641          checkCompletedNormally(g, v1);
1642 <        }
1539 <    }
1642 >    }}
1643  
1644      /**
1645       * runAfterBoth result completes normally after normal
# Line 1545 | Line 1648 | public class CompletableFutureTest exten
1648      public void testRunAfterBoth_normalCompletion1() {
1649          for (ExecutionMode m : ExecutionMode.values())
1650          for (Integer v1 : new Integer[] { 1, null })
1651 <        for (Integer v2 : new Integer[] { 2, null }) {
1652 <
1651 >        for (Integer v2 : new Integer[] { 2, null })
1652 >    {
1653          final CompletableFuture<Integer> f = new CompletableFuture<>();
1654          final CompletableFuture<Integer> g = new CompletableFuture<>();
1655          final Noop r = new Noop();
# Line 1554 | Line 1657 | public class CompletableFutureTest exten
1657  
1658          f.complete(v1);
1659          checkIncomplete(h);
1660 <        assertFalse(r.ran);
1660 >        assertEquals(0, r.invocationCount);
1661          g.complete(v2);
1662  
1663          checkCompletedNormally(h, null);
1664 <        assertTrue(r.ran);
1664 >        assertEquals(1, r.invocationCount);
1665          checkCompletedNormally(f, v1);
1666          checkCompletedNormally(g, v2);
1667 <        }
1565 <    }
1667 >    }}
1668  
1669      public void testRunAfterBoth_normalCompletion2() {
1670          for (ExecutionMode m : ExecutionMode.values())
1671          for (Integer v1 : new Integer[] { 1, null })
1672 <        for (Integer v2 : new Integer[] { 2, null }) {
1673 <
1672 >        for (Integer v2 : new Integer[] { 2, null })
1673 >    {
1674          final CompletableFuture<Integer> f = new CompletableFuture<>();
1675          final CompletableFuture<Integer> g = new CompletableFuture<>();
1676          final Noop r = new Noop();
# Line 1576 | Line 1678 | public class CompletableFutureTest exten
1678  
1679          g.complete(v2);
1680          checkIncomplete(h);
1681 <        assertFalse(r.ran);
1681 >        assertEquals(0, r.invocationCount);
1682          f.complete(v1);
1683  
1684          checkCompletedNormally(h, null);
1685 <        assertTrue(r.ran);
1685 >        assertEquals(1, r.invocationCount);
1686          checkCompletedNormally(f, v1);
1687          checkCompletedNormally(g, v2);
1688 <        }
1587 <    }
1688 >    }}
1689  
1690      public void testRunAfterBoth_normalCompletion3() {
1691          for (ExecutionMode m : ExecutionMode.values())
1692          for (Integer v1 : new Integer[] { 1, null })
1693 <        for (Integer v2 : new Integer[] { 2, null }) {
1694 <
1693 >        for (Integer v2 : new Integer[] { 2, null })
1694 >    {
1695          final CompletableFuture<Integer> f = new CompletableFuture<>();
1696          final CompletableFuture<Integer> g = new CompletableFuture<>();
1697          final Noop r = new Noop();
# Line 1600 | Line 1701 | public class CompletableFutureTest exten
1701          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1702  
1703          checkCompletedNormally(h, null);
1704 <        assertTrue(r.ran);
1704 >        assertEquals(1, r.invocationCount);
1705          checkCompletedNormally(f, v1);
1706          checkCompletedNormally(g, v2);
1707 <        }
1607 <    }
1707 >    }}
1708  
1709      public void testRunAfterBoth_normalCompletion4() {
1710          for (ExecutionMode m : ExecutionMode.values())
1711          for (Integer v1 : new Integer[] { 1, null })
1712 <        for (Integer v2 : new Integer[] { 2, null }) {
1713 <
1712 >        for (Integer v2 : new Integer[] { 2, null })
1713 >    {
1714          final CompletableFuture<Integer> f = new CompletableFuture<>();
1715          final CompletableFuture<Integer> g = new CompletableFuture<>();
1716          final Noop r = new Noop();
# Line 1620 | Line 1720 | public class CompletableFutureTest exten
1720          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1721  
1722          checkCompletedNormally(h, null);
1723 <        assertTrue(r.ran);
1723 >        assertEquals(1, r.invocationCount);
1724          checkCompletedNormally(f, v1);
1725          checkCompletedNormally(g, v2);
1726 <        }
1627 <    }
1726 >    }}
1727  
1728      /**
1729       * runAfterBoth result completes exceptionally after exceptional
# Line 1632 | Line 1731 | public class CompletableFutureTest exten
1731       */
1732      public void testRunAfterBoth_exceptionalCompletion1() {
1733          for (ExecutionMode m : ExecutionMode.values())
1734 <        for (Integer v1 : new Integer[] { 1, null }) {
1735 <
1734 >        for (Integer v1 : new Integer[] { 1, null })
1735 >    {
1736          final CompletableFuture<Integer> f = new CompletableFuture<>();
1737          final CompletableFuture<Integer> g = new CompletableFuture<>();
1738          final Noop r = new Noop();
# Line 1646 | Line 1745 | public class CompletableFutureTest exten
1745  
1746          checkCompletedWithWrappedCFException(h, ex);
1747          checkCompletedWithWrappedCFException(f, ex);
1748 <        assertFalse(r.ran);
1748 >        assertEquals(0, r.invocationCount);
1749          checkCompletedNormally(g, v1);
1750 <        }
1652 <    }
1750 >    }}
1751  
1752      public void testRunAfterBoth_exceptionalCompletion2() {
1753          for (ExecutionMode m : ExecutionMode.values())
1754 <        for (Integer v1 : new Integer[] { 1, null }) {
1755 <
1754 >        for (Integer v1 : new Integer[] { 1, null })
1755 >    {
1756          final CompletableFuture<Integer> f = new CompletableFuture<>();
1757          final CompletableFuture<Integer> g = new CompletableFuture<>();
1758          final Noop r = new Noop();
# Line 1667 | Line 1765 | public class CompletableFutureTest exten
1765  
1766          checkCompletedWithWrappedCFException(h, ex);
1767          checkCompletedWithWrappedCFException(g, ex);
1768 <        assertFalse(r.ran);
1768 >        assertEquals(0, r.invocationCount);
1769          checkCompletedNormally(f, v1);
1770 <        }
1673 <    }
1770 >    }}
1771  
1772      public void testRunAfterBoth_exceptionalCompletion3() {
1773          for (ExecutionMode m : ExecutionMode.values())
1774 <        for (Integer v1 : new Integer[] { 1, null }) {
1775 <
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 Noop r = new Noop();
# Line 1687 | Line 1784 | public class CompletableFutureTest exten
1784  
1785          checkCompletedWithWrappedCFException(h, ex);
1786          checkCompletedWithWrappedCFException(g, ex);
1787 <        assertFalse(r.ran);
1787 >        assertEquals(0, r.invocationCount);
1788          checkCompletedNormally(f, v1);
1789 <        }
1693 <    }
1789 >    }}
1790  
1791      public void testRunAfterBoth_exceptionalCompletion4() {
1792          for (ExecutionMode m : ExecutionMode.values())
1793 <        for (Integer v1 : new Integer[] { 1, null }) {
1794 <
1793 >        for (Integer v1 : new Integer[] { 1, null })
1794 >    {
1795          final CompletableFuture<Integer> f = new CompletableFuture<>();
1796          final CompletableFuture<Integer> g = new CompletableFuture<>();
1797          final Noop r = new Noop();
# Line 1707 | Line 1803 | public class CompletableFutureTest exten
1803  
1804          checkCompletedWithWrappedCFException(h, ex);
1805          checkCompletedWithWrappedCFException(f, ex);
1806 <        assertFalse(r.ran);
1806 >        assertEquals(0, r.invocationCount);
1807          checkCompletedNormally(g, v1);
1808 <        }
1713 <    }
1808 >    }}
1809  
1810      /**
1811       * runAfterBoth result completes exceptionally if action does
# Line 1718 | Line 1813 | public class CompletableFutureTest exten
1813      public void testRunAfterBoth_actionFailed1() {
1814          for (ExecutionMode m : ExecutionMode.values())
1815          for (Integer v1 : new Integer[] { 1, null })
1816 <        for (Integer v2 : new Integer[] { 2, null }) {
1817 <
1816 >        for (Integer v2 : new Integer[] { 2, null })
1817 >    {
1818          final CompletableFuture<Integer> f = new CompletableFuture<>();
1819          final CompletableFuture<Integer> g = new CompletableFuture<>();
1820 <        final FailingNoop r = new FailingNoop();
1820 >        final FailingRunnable r = new FailingRunnable();
1821          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1822  
1823          f.complete(v1);
# Line 1732 | Line 1827 | public class CompletableFutureTest exten
1827          checkCompletedWithWrappedCFException(h);
1828          checkCompletedNormally(f, v1);
1829          checkCompletedNormally(g, v2);
1830 <        }
1736 <    }
1830 >    }}
1831  
1832      public void testRunAfterBoth_actionFailed2() {
1833          for (ExecutionMode m : ExecutionMode.values())
1834          for (Integer v1 : new Integer[] { 1, null })
1835 <        for (Integer v2 : new Integer[] { 2, null }) {
1836 <
1835 >        for (Integer v2 : new Integer[] { 2, null })
1836 >    {
1837          final CompletableFuture<Integer> f = new CompletableFuture<>();
1838          final CompletableFuture<Integer> g = new CompletableFuture<>();
1839 <        final FailingNoop r = new FailingNoop();
1839 >        final FailingRunnable r = new FailingRunnable();
1840          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1841  
1842          g.complete(v2);
# Line 1752 | Line 1846 | public class CompletableFutureTest exten
1846          checkCompletedWithWrappedCFException(h);
1847          checkCompletedNormally(f, v1);
1848          checkCompletedNormally(g, v2);
1849 <        }
1756 <    }
1849 >    }}
1850  
1851      /**
1852       * runAfterBoth result completes exceptionally if either source cancelled
# Line 1761 | Line 1854 | public class CompletableFutureTest exten
1854      public void testRunAfterBoth_sourceCancelled1() {
1855          for (ExecutionMode m : ExecutionMode.values())
1856          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1857 <        for (Integer v1 : new Integer[] { 1, null }) {
1858 <
1857 >        for (Integer v1 : new Integer[] { 1, null })
1858 >    {
1859          final CompletableFuture<Integer> f = new CompletableFuture<>();
1860          final CompletableFuture<Integer> g = new CompletableFuture<>();
1861          final Noop r = new Noop();
# Line 1774 | Line 1867 | public class CompletableFutureTest exten
1867  
1868          checkCompletedWithWrappedCancellationException(h);
1869          checkCancelled(f);
1870 <        assertFalse(r.ran);
1870 >        assertEquals(0, r.invocationCount);
1871          checkCompletedNormally(g, v1);
1872 <        }
1780 <    }
1872 >    }}
1873  
1874      public void testRunAfterBoth_sourceCancelled2() {
1875          for (ExecutionMode m : ExecutionMode.values())
1876          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1877 <        for (Integer v1 : new Integer[] { 1, null }) {
1878 <
1877 >        for (Integer v1 : new Integer[] { 1, null })
1878 >    {
1879          final CompletableFuture<Integer> f = new CompletableFuture<>();
1880          final CompletableFuture<Integer> g = new CompletableFuture<>();
1881          final Noop r = new Noop();
# Line 1795 | Line 1887 | public class CompletableFutureTest exten
1887  
1888          checkCompletedWithWrappedCancellationException(h);
1889          checkCancelled(g);
1890 <        assertFalse(r.ran);
1890 >        assertEquals(0, r.invocationCount);
1891          checkCompletedNormally(f, v1);
1892 <        }
1801 <    }
1892 >    }}
1893  
1894      public void testRunAfterBoth_sourceCancelled3() {
1895          for (ExecutionMode m : ExecutionMode.values())
1896          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1897 <        for (Integer v1 : new Integer[] { 1, null }) {
1898 <
1897 >        for (Integer v1 : new Integer[] { 1, null })
1898 >    {
1899          final CompletableFuture<Integer> f = new CompletableFuture<>();
1900          final CompletableFuture<Integer> g = new CompletableFuture<>();
1901          final Noop r = new Noop();
# Line 1815 | Line 1906 | public class CompletableFutureTest exten
1906  
1907          checkCompletedWithWrappedCancellationException(h);
1908          checkCancelled(g);
1909 <        assertFalse(r.ran);
1909 >        assertEquals(0, r.invocationCount);
1910          checkCompletedNormally(f, v1);
1911 <        }
1821 <    }
1911 >    }}
1912  
1913      public void testRunAfterBoth_sourceCancelled4() {
1914          for (ExecutionMode m : ExecutionMode.values())
1915          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1916 <        for (Integer v1 : new Integer[] { 1, null }) {
1917 <
1916 >        for (Integer v1 : new Integer[] { 1, null })
1917 >    {
1918          final CompletableFuture<Integer> f = new CompletableFuture<>();
1919          final CompletableFuture<Integer> g = new CompletableFuture<>();
1920          final Noop r = new Noop();
# Line 1835 | Line 1925 | public class CompletableFutureTest exten
1925  
1926          checkCompletedWithWrappedCancellationException(h);
1927          checkCancelled(f);
1928 <        assertFalse(r.ran);
1928 >        assertEquals(0, r.invocationCount);
1929          checkCompletedNormally(g, v1);
1930 <        }
1841 <    }
1930 >    }}
1931  
1932      /**
1933       * applyToEither result completes normally after normal completion
# Line 1847 | Line 1936 | public class CompletableFutureTest exten
1936      public void testApplyToEither_normalCompletion1() {
1937          for (ExecutionMode m : ExecutionMode.values())
1938          for (Integer v1 : new Integer[] { 1, null })
1939 <        for (Integer v2 : new Integer[] { 2, null }) {
1940 <
1939 >        for (Integer v2 : new Integer[] { 2, null })
1940 >    {
1941          final CompletableFuture<Integer> f = new CompletableFuture<>();
1942          final CompletableFuture<Integer> g = new CompletableFuture<>();
1943          final IncFunction r = new IncFunction();
# Line 1861 | Line 1950 | public class CompletableFutureTest exten
1950          checkCompletedNormally(f, v1);
1951          checkCompletedNormally(g, v2);
1952          checkCompletedNormally(h, inc(v1));
1953 <        }
1865 <    }
1953 >    }}
1954  
1955      public void testApplyToEither_normalCompletion2() {
1956          for (ExecutionMode m : ExecutionMode.values())
1957          for (Integer v1 : new Integer[] { 1, null })
1958 <        for (Integer v2 : new Integer[] { 2, null }) {
1959 <
1958 >        for (Integer v2 : new Integer[] { 2, null })
1959 >    {
1960          final CompletableFuture<Integer> f = new CompletableFuture<>();
1961          final CompletableFuture<Integer> g = new CompletableFuture<>();
1962          final IncFunction r = new IncFunction();
# Line 1881 | Line 1969 | public class CompletableFutureTest exten
1969          checkCompletedNormally(f, v1);
1970          checkCompletedNormally(g, v2);
1971          checkCompletedNormally(h, inc(v2));
1972 <        }
1973 <    }
1972 >        }}
1973 >
1974      public void testApplyToEither_normalCompletion3() {
1975          for (ExecutionMode m : ExecutionMode.values())
1976          for (Integer v1 : new Integer[] { 1, null })
1977 <        for (Integer v2 : new Integer[] { 2, null }) {
1978 <
1977 >        for (Integer v2 : new Integer[] { 2, null })
1978 >    {
1979          final CompletableFuture<Integer> f = new CompletableFuture<>();
1980          final CompletableFuture<Integer> g = new CompletableFuture<>();
1981          final IncFunction r = new IncFunction();
# Line 1902 | Line 1990 | public class CompletableFutureTest exten
1990          // unspecified behavior
1991          assertTrue(Objects.equals(h.join(), inc(v1)) ||
1992                     Objects.equals(h.join(), inc(v2)));
1993 <        }
1994 <    }
1993 >        assertEquals(1, r.invocationCount);
1994 >    }}
1995  
1996      /**
1997       * applyToEither result completes exceptionally after exceptional
# Line 1911 | Line 1999 | public class CompletableFutureTest exten
1999       */
2000      public void testApplyToEither_exceptionalCompletion1() {
2001          for (ExecutionMode m : ExecutionMode.values())
2002 <        for (Integer v1 : new Integer[] { 1, null }) {
2003 <
2002 >        for (Integer v1 : new Integer[] { 1, null })
2003 >    {
2004          final CompletableFuture<Integer> f = new CompletableFuture<>();
2005          final CompletableFuture<Integer> g = new CompletableFuture<>();
2006          final IncFunction r = new IncFunction();
# Line 1923 | Line 2011 | public class CompletableFutureTest exten
2011          checkCompletedWithWrappedCFException(h, ex);
2012          g.complete(v1);
2013  
2014 <        assertFalse(r.ran());
2014 >        assertEquals(0, r.invocationCount);
2015          checkCompletedNormally(g, v1);
2016          checkCompletedWithWrappedCFException(f, ex);
2017          checkCompletedWithWrappedCFException(h, ex);
2018 <        }
1931 <    }
2018 >    }}
2019  
2020      public void testApplyToEither_exceptionalCompletion2() {
2021          for (ExecutionMode m : ExecutionMode.values())
2022 <        for (Integer v1 : new Integer[] { 1, null }) {
2023 <
2022 >        for (Integer v1 : new Integer[] { 1, null })
2023 >    {
2024          final CompletableFuture<Integer> f = new CompletableFuture<>();
2025          final CompletableFuture<Integer> g = new CompletableFuture<>();
2026          final IncFunction r = new IncFunction();
# Line 1944 | Line 2031 | public class CompletableFutureTest exten
2031          checkCompletedWithWrappedCFException(h, ex);
2032          f.complete(v1);
2033  
2034 <        assertFalse(r.ran());
2034 >        assertEquals(0, r.invocationCount);
2035          checkCompletedNormally(f, v1);
2036          checkCompletedWithWrappedCFException(g, ex);
2037          checkCompletedWithWrappedCFException(h, ex);
2038 <        }
1952 <    }
2038 >    }}
2039  
2040      public void testApplyToEither_exceptionalCompletion3() {
2041          for (ExecutionMode m : ExecutionMode.values())
2042 <        for (Integer v1 : new Integer[] { 1, null }) {
2043 <
2042 >        for (Integer v1 : new Integer[] { 1, null })
2043 >    {
2044          final CompletableFuture<Integer> f = new CompletableFuture<>();
2045          final CompletableFuture<Integer> g = new CompletableFuture<>();
2046          final IncFunction r = new IncFunction();
# Line 1967 | Line 2053 | public class CompletableFutureTest exten
2053          // unspecified behavior
2054          Integer v;
2055          try {
2056 <            assertEquals(h.join(), inc(v1));
2057 <            assertTrue(r.ran());
2056 >            assertEquals(inc(v1), h.join());
2057 >            assertEquals(1, r.invocationCount);
2058          } catch (CompletionException ok) {
2059              checkCompletedWithWrappedCFException(h, ex);
2060 <            assertFalse(r.ran());
2060 >            assertEquals(0, r.invocationCount);
2061          }
2062  
2063          checkCompletedWithWrappedCFException(g, ex);
2064          checkCompletedNormally(f, v1);
2065 <        }
1980 <    }
2065 >    }}
2066  
2067      public void testApplyToEither_exceptionalCompletion4() {
2068          for (ExecutionMode m : ExecutionMode.values())
2069 <        for (Integer v1 : new Integer[] { 1, null }) {
2070 <
2069 >        for (Integer v1 : new Integer[] { 1, null })
2070 >    {
2071          final CompletableFuture<Integer> f = new CompletableFuture<>();
2072          final CompletableFuture<Integer> g = new CompletableFuture<>();
2073          final IncFunction r = new IncFunction();
# Line 1995 | Line 2080 | public class CompletableFutureTest exten
2080          // unspecified behavior
2081          Integer v;
2082          try {
2083 <            assertEquals(h.join(), inc(v1));
2084 <            assertTrue(r.ran());
2083 >            assertEquals(inc(v1), h.join());
2084 >            assertEquals(1, r.invocationCount);
2085          } catch (CompletionException ok) {
2086              checkCompletedWithWrappedCFException(h, ex);
2087 <            assertFalse(r.ran());
2087 >            assertEquals(0, r.invocationCount);
2088          }
2089  
2090          checkCompletedWithWrappedCFException(f, ex);
2006        assertFalse(r.ran());
2091          checkCompletedNormally(g, v1);
2092 <        }
2009 <    }
2092 >    }}
2093  
2094      /**
2095       * applyToEither result completes exceptionally if action does
# Line 2014 | Line 2097 | public class CompletableFutureTest exten
2097      public void testApplyToEither_actionFailed1() {
2098          for (ExecutionMode m : ExecutionMode.values())
2099          for (Integer v1 : new Integer[] { 1, null })
2100 <        for (Integer v2 : new Integer[] { 2, null }) {
2101 <
2100 >        for (Integer v2 : new Integer[] { 2, null })
2101 >    {
2102          final CompletableFuture<Integer> f = new CompletableFuture<>();
2103          final CompletableFuture<Integer> g = new CompletableFuture<>();
2104          final FailingFunction r = new FailingFunction();
# Line 2026 | Line 2109 | public class CompletableFutureTest exten
2109          g.complete(v2);
2110          checkCompletedNormally(f, v1);
2111          checkCompletedNormally(g, v2);
2112 <        }
2030 <    }
2112 >    }}
2113  
2114      public void testApplyToEither_actionFailed2() {
2115          for (ExecutionMode m : ExecutionMode.values())
2116          for (Integer v1 : new Integer[] { 1, null })
2117 <        for (Integer v2 : new Integer[] { 2, null }) {
2118 <
2117 >        for (Integer v2 : new Integer[] { 2, null })
2118 >    {
2119          final CompletableFuture<Integer> f = new CompletableFuture<>();
2120          final CompletableFuture<Integer> g = new CompletableFuture<>();
2121          final FailingFunction r = new FailingFunction();
# Line 2044 | Line 2126 | public class CompletableFutureTest exten
2126          f.complete(v1);
2127          checkCompletedNormally(f, v1);
2128          checkCompletedNormally(g, v2);
2129 <        }
2048 <    }
2129 >    }}
2130  
2131      /**
2132       * applyToEither result completes exceptionally if either source cancelled
# Line 2053 | Line 2134 | public class CompletableFutureTest exten
2134      public void testApplyToEither_sourceCancelled1() {
2135          for (ExecutionMode m : ExecutionMode.values())
2136          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2137 <        for (Integer v1 : new Integer[] { 1, null }) {
2138 <
2137 >        for (Integer v1 : new Integer[] { 1, null })
2138 >    {
2139          final CompletableFuture<Integer> f = new CompletableFuture<>();
2140          final CompletableFuture<Integer> g = new CompletableFuture<>();
2141          final IncFunction r = new IncFunction();
# Line 2065 | Line 2146 | public class CompletableFutureTest exten
2146          g.complete(v1);
2147  
2148          checkCancelled(f);
2149 <        assertFalse(r.ran());
2149 >        assertEquals(0, r.invocationCount);
2150          checkCompletedNormally(g, v1);
2151          checkCompletedWithWrappedCancellationException(h);
2152 <        }
2072 <    }
2152 >    }}
2153  
2154      public void testApplyToEither_sourceCancelled2() {
2155          for (ExecutionMode m : ExecutionMode.values())
2156          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2157 <        for (Integer v1 : new Integer[] { 1, null }) {
2158 <
2157 >        for (Integer v1 : new Integer[] { 1, null })
2158 >    {
2159          final CompletableFuture<Integer> f = new CompletableFuture<>();
2160          final CompletableFuture<Integer> g = new CompletableFuture<>();
2161          final IncFunction r = new IncFunction();
# Line 2086 | Line 2166 | public class CompletableFutureTest exten
2166          f.complete(v1);
2167  
2168          checkCancelled(g);
2169 <        assertFalse(r.ran());
2169 >        assertEquals(0, r.invocationCount);
2170          checkCompletedNormally(f, v1);
2171          checkCompletedWithWrappedCancellationException(h);
2172 <        }
2093 <    }
2172 >    }}
2173  
2174      public void testApplyToEither_sourceCancelled3() {
2175          for (ExecutionMode m : ExecutionMode.values())
2176          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2177 <        for (Integer v1 : new Integer[] { 1, null }) {
2178 <
2177 >        for (Integer v1 : new Integer[] { 1, null })
2178 >    {
2179          final CompletableFuture<Integer> f = new CompletableFuture<>();
2180          final CompletableFuture<Integer> g = new CompletableFuture<>();
2181          final IncFunction r = new IncFunction();
# Line 2108 | Line 2187 | public class CompletableFutureTest exten
2187          // unspecified behavior
2188          Integer v;
2189          try {
2190 <            assertEquals(h.join(), inc(v1));
2191 <            assertTrue(r.ran());
2190 >            assertEquals(inc(v1), h.join());
2191 >            assertEquals(1, r.invocationCount);
2192          } catch (CompletionException ok) {
2193              checkCompletedWithWrappedCancellationException(h);
2194 <            assertFalse(r.ran());
2194 >            assertEquals(0, r.invocationCount);
2195          }
2196  
2197          checkCancelled(g);
2198          checkCompletedNormally(f, v1);
2199 <        }
2121 <    }
2199 >    }}
2200  
2201      public void testApplyToEither_sourceCancelled4() {
2202          for (ExecutionMode m : ExecutionMode.values())
2203          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2204 <        for (Integer v1 : new Integer[] { 1, null }) {
2205 <
2204 >        for (Integer v1 : new Integer[] { 1, null })
2205 >    {
2206          final CompletableFuture<Integer> f = new CompletableFuture<>();
2207          final CompletableFuture<Integer> g = new CompletableFuture<>();
2208          final IncFunction r = new IncFunction();
# Line 2136 | Line 2214 | public class CompletableFutureTest exten
2214          // unspecified behavior
2215          Integer v;
2216          try {
2217 <            assertEquals(h.join(), inc(v1));
2218 <            assertTrue(r.ran());
2217 >            assertEquals(inc(v1), h.join());
2218 >            assertEquals(1, r.invocationCount);
2219          } catch (CompletionException ok) {
2220              checkCompletedWithWrappedCancellationException(h);
2221 <            assertFalse(r.ran());
2221 >            assertEquals(0, r.invocationCount);
2222          }
2223  
2224          checkCancelled(f);
2225          checkCompletedNormally(g, v1);
2226 <        }
2149 <    }
2226 >    }}
2227  
2228      /**
2229       * acceptEither result completes normally after normal completion
# Line 2155 | Line 2232 | public class CompletableFutureTest exten
2232      public void testAcceptEither_normalCompletion1() {
2233          for (ExecutionMode m : ExecutionMode.values())
2234          for (Integer v1 : new Integer[] { 1, null })
2235 <        for (Integer v2 : new Integer[] { 2, null }) {
2236 <
2235 >        for (Integer v2 : new Integer[] { 2, null })
2236 >    {
2237          final CompletableFuture<Integer> f = new CompletableFuture<>();
2238          final CompletableFuture<Integer> g = new CompletableFuture<>();
2239          final IncAction r = new IncAction();
# Line 2164 | Line 2241 | public class CompletableFutureTest exten
2241  
2242          f.complete(v1);
2243          checkCompletedNormally(h, null);
2244 <        assertEquals(r.value, inc(v1));
2244 >        assertEquals(inc(v1), r.value);
2245          g.complete(v2);
2246  
2247          checkCompletedNormally(f, v1);
2248          checkCompletedNormally(g, v2);
2249          checkCompletedNormally(h, null);
2250 <        }
2174 <    }
2250 >    }}
2251  
2252      public void testAcceptEither_normalCompletion2() {
2253          for (ExecutionMode m : ExecutionMode.values())
2254          for (Integer v1 : new Integer[] { 1, null })
2255 <        for (Integer v2 : new Integer[] { 2, null }) {
2256 <
2255 >        for (Integer v2 : new Integer[] { 2, null })
2256 >    {
2257          final CompletableFuture<Integer> f = new CompletableFuture<>();
2258          final CompletableFuture<Integer> g = new CompletableFuture<>();
2259          final IncAction r = new IncAction();
# Line 2185 | Line 2261 | public class CompletableFutureTest exten
2261  
2262          g.complete(v2);
2263          checkCompletedNormally(h, null);
2264 <        assertEquals(r.value, inc(v2));
2264 >        assertEquals(inc(v2), r.value);
2265          f.complete(v1);
2266  
2267          checkCompletedNormally(f, v1);
2268          checkCompletedNormally(g, v2);
2269          checkCompletedNormally(h, null);
2270 <        }
2271 <    }
2270 >    }}
2271 >
2272      public void testAcceptEither_normalCompletion3() {
2273          for (ExecutionMode m : ExecutionMode.values())
2274          for (Integer v1 : new Integer[] { 1, null })
2275 <        for (Integer v2 : new Integer[] { 2, null }) {
2276 <
2275 >        for (Integer v2 : new Integer[] { 2, null })
2276 >    {
2277          final CompletableFuture<Integer> f = new CompletableFuture<>();
2278          final CompletableFuture<Integer> g = new CompletableFuture<>();
2279          final IncAction r = new IncAction();
# Line 2213 | Line 2289 | public class CompletableFutureTest exten
2289          // unspecified behavior
2290          assertTrue(Objects.equals(r.value, inc(v1)) ||
2291                     Objects.equals(r.value, inc(v2)));
2292 <        }
2217 <    }
2292 >    }}
2293  
2294      /**
2295       * acceptEither result completes exceptionally after exceptional
# Line 2222 | Line 2297 | public class CompletableFutureTest exten
2297       */
2298      public void testAcceptEither_exceptionalCompletion1() {
2299          for (ExecutionMode m : ExecutionMode.values())
2300 <        for (Integer v1 : new Integer[] { 1, null }) {
2301 <
2300 >        for (Integer v1 : new Integer[] { 1, null })
2301 >    {
2302          final CompletableFuture<Integer> f = new CompletableFuture<>();
2303          final CompletableFuture<Integer> g = new CompletableFuture<>();
2304          final IncAction r = new IncAction();
# Line 2234 | Line 2309 | public class CompletableFutureTest exten
2309          checkCompletedWithWrappedCFException(h, ex);
2310          g.complete(v1);
2311  
2312 <        assertFalse(r.ran());
2312 >        assertEquals(0, r.invocationCount);
2313          checkCompletedNormally(g, v1);
2314          checkCompletedWithWrappedCFException(f, ex);
2315          checkCompletedWithWrappedCFException(h, ex);
2316 <        }
2242 <    }
2316 >    }}
2317  
2318      public void testAcceptEither_exceptionalCompletion2() {
2319          for (ExecutionMode m : ExecutionMode.values())
2320 <        for (Integer v1 : new Integer[] { 1, null }) {
2321 <
2320 >        for (Integer v1 : new Integer[] { 1, null })
2321 >    {
2322          final CompletableFuture<Integer> f = new CompletableFuture<>();
2323          final CompletableFuture<Integer> g = new CompletableFuture<>();
2324          final IncAction r = new IncAction();
# Line 2255 | Line 2329 | public class CompletableFutureTest exten
2329          checkCompletedWithWrappedCFException(h, ex);
2330          f.complete(v1);
2331  
2332 <        assertFalse(r.ran());
2332 >        assertEquals(0, r.invocationCount);
2333          checkCompletedNormally(f, v1);
2334          checkCompletedWithWrappedCFException(g, ex);
2335          checkCompletedWithWrappedCFException(h, ex);
2336 <        }
2263 <    }
2336 >    }}
2337  
2338      public void testAcceptEither_exceptionalCompletion3() {
2339          for (ExecutionMode m : ExecutionMode.values())
2340 <        for (Integer v1 : new Integer[] { 1, null }) {
2341 <
2340 >        for (Integer v1 : new Integer[] { 1, null })
2341 >    {
2342          final CompletableFuture<Integer> f = new CompletableFuture<>();
2343          final CompletableFuture<Integer> g = new CompletableFuture<>();
2344          final IncAction r = new IncAction();
# Line 2278 | Line 2351 | public class CompletableFutureTest exten
2351          // unspecified behavior
2352          Integer v;
2353          try {
2354 <            assertEquals(h.join(), null);
2355 <            assertTrue(r.ran());
2354 >            assertNull(h.join());
2355 >            assertEquals(1, r.invocationCount);
2356              assertEquals(inc(v1), r.value);
2357          } catch (CompletionException ok) {
2358              checkCompletedWithWrappedCFException(h, ex);
2359 <            assertFalse(r.ran());
2359 >            assertEquals(0, r.invocationCount);
2360          }
2361  
2362          checkCompletedWithWrappedCFException(g, ex);
2363          checkCompletedNormally(f, v1);
2364 <        }
2292 <    }
2364 >    }}
2365  
2366      public void testAcceptEither_exceptionalCompletion4() {
2367          for (ExecutionMode m : ExecutionMode.values())
2368 <        for (Integer v1 : new Integer[] { 1, null }) {
2369 <
2368 >        for (Integer v1 : new Integer[] { 1, null })
2369 >    {
2370          final CompletableFuture<Integer> f = new CompletableFuture<>();
2371          final CompletableFuture<Integer> g = new CompletableFuture<>();
2372          final IncAction r = new IncAction();
# Line 2307 | Line 2379 | public class CompletableFutureTest exten
2379          // unspecified behavior
2380          Integer v;
2381          try {
2382 <            assertEquals(h.join(), null);
2383 <            assertTrue(r.ran());
2382 >            assertNull(h.join());
2383 >            assertEquals(1, r.invocationCount);
2384              assertEquals(inc(v1), r.value);
2385          } catch (CompletionException ok) {
2386              checkCompletedWithWrappedCFException(h, ex);
2387 <            assertFalse(r.ran());
2387 >            assertEquals(0, r.invocationCount);
2388          }
2389  
2390          checkCompletedWithWrappedCFException(f, ex);
2319        assertFalse(r.ran());
2391          checkCompletedNormally(g, v1);
2392 <        }
2322 <    }
2392 >    }}
2393  
2394      /**
2395       * acceptEither result completes exceptionally if action does
# Line 2327 | Line 2397 | public class CompletableFutureTest exten
2397      public void testAcceptEither_actionFailed1() {
2398          for (ExecutionMode m : ExecutionMode.values())
2399          for (Integer v1 : new Integer[] { 1, null })
2400 <        for (Integer v2 : new Integer[] { 2, null }) {
2401 <
2400 >        for (Integer v2 : new Integer[] { 2, null })
2401 >    {
2402          final CompletableFuture<Integer> f = new CompletableFuture<>();
2403          final CompletableFuture<Integer> g = new CompletableFuture<>();
2404          final FailingConsumer r = new FailingConsumer();
# Line 2339 | Line 2409 | public class CompletableFutureTest exten
2409          g.complete(v2);
2410          checkCompletedNormally(f, v1);
2411          checkCompletedNormally(g, v2);
2412 <        }
2343 <    }
2412 >    }}
2413  
2414      public void testAcceptEither_actionFailed2() {
2415          for (ExecutionMode m : ExecutionMode.values())
2416          for (Integer v1 : new Integer[] { 1, null })
2417 <        for (Integer v2 : new Integer[] { 2, null }) {
2418 <
2417 >        for (Integer v2 : new Integer[] { 2, null })
2418 >    {
2419          final CompletableFuture<Integer> f = new CompletableFuture<>();
2420          final CompletableFuture<Integer> g = new CompletableFuture<>();
2421          final FailingConsumer r = new FailingConsumer();
# Line 2357 | Line 2426 | public class CompletableFutureTest exten
2426          f.complete(v1);
2427          checkCompletedNormally(f, v1);
2428          checkCompletedNormally(g, v2);
2429 <        }
2361 <    }
2429 >    }}
2430  
2431      /**
2432       * acceptEither result completes exceptionally if either source cancelled
# Line 2366 | Line 2434 | public class CompletableFutureTest exten
2434      public void testAcceptEither_sourceCancelled1() {
2435          for (ExecutionMode m : ExecutionMode.values())
2436          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2437 <        for (Integer v1 : new Integer[] { 1, null }) {
2438 <
2437 >        for (Integer v1 : new Integer[] { 1, null })
2438 >    {
2439          final CompletableFuture<Integer> f = new CompletableFuture<>();
2440          final CompletableFuture<Integer> g = new CompletableFuture<>();
2441          final IncAction r = new IncAction();
# Line 2378 | Line 2446 | public class CompletableFutureTest exten
2446          g.complete(v1);
2447  
2448          checkCancelled(f);
2449 <        assertFalse(r.ran());
2449 >        assertEquals(0, r.invocationCount);
2450          checkCompletedNormally(g, v1);
2451          checkCompletedWithWrappedCancellationException(h);
2452 <        }
2385 <    }
2452 >    }}
2453  
2454      public void testAcceptEither_sourceCancelled2() {
2455          for (ExecutionMode m : ExecutionMode.values())
2456          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2457 <        for (Integer v1 : new Integer[] { 1, null }) {
2458 <
2457 >        for (Integer v1 : new Integer[] { 1, null })
2458 >    {
2459          final CompletableFuture<Integer> f = new CompletableFuture<>();
2460          final CompletableFuture<Integer> g = new CompletableFuture<>();
2461          final IncAction r = new IncAction();
# Line 2399 | Line 2466 | public class CompletableFutureTest exten
2466          f.complete(v1);
2467  
2468          checkCancelled(g);
2469 <        assertFalse(r.ran());
2469 >        assertEquals(0, r.invocationCount);
2470          checkCompletedNormally(f, v1);
2471          checkCompletedWithWrappedCancellationException(h);
2472 <        }
2406 <    }
2472 >    }}
2473  
2474      public void testAcceptEither_sourceCancelled3() {
2475          for (ExecutionMode m : ExecutionMode.values())
2476          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2477 <        for (Integer v1 : new Integer[] { 1, null }) {
2478 <
2477 >        for (Integer v1 : new Integer[] { 1, null })
2478 >    {
2479          final CompletableFuture<Integer> f = new CompletableFuture<>();
2480          final CompletableFuture<Integer> g = new CompletableFuture<>();
2481          final IncAction r = new IncAction();
# Line 2421 | Line 2487 | public class CompletableFutureTest exten
2487          // unspecified behavior
2488          Integer v;
2489          try {
2490 <            assertEquals(h.join(), null);
2491 <            assertTrue(r.ran());
2490 >            assertNull(h.join());
2491 >            assertEquals(1, r.invocationCount);
2492              assertEquals(inc(v1), r.value);
2493          } catch (CompletionException ok) {
2494              checkCompletedWithWrappedCancellationException(h);
2495 <            assertFalse(r.ran());
2495 >            assertEquals(0, r.invocationCount);
2496          }
2497  
2498          checkCancelled(g);
2499          checkCompletedNormally(f, v1);
2500 <        }
2435 <    }
2500 >    }}
2501  
2502      public void testAcceptEither_sourceCancelled4() {
2503          for (ExecutionMode m : ExecutionMode.values())
2504          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2505 <        for (Integer v1 : new Integer[] { 1, null }) {
2506 <
2505 >        for (Integer v1 : new Integer[] { 1, null })
2506 >    {
2507          final CompletableFuture<Integer> f = new CompletableFuture<>();
2508          final CompletableFuture<Integer> g = new CompletableFuture<>();
2509          final IncAction r = new IncAction();
# Line 2450 | Line 2515 | public class CompletableFutureTest exten
2515          // unspecified behavior
2516          Integer v;
2517          try {
2518 <            assertEquals(h.join(), null);
2519 <            assertTrue(r.ran());
2518 >            assertNull(h.join());
2519 >            assertEquals(1, r.invocationCount);
2520              assertEquals(inc(v1), r.value);
2521          } catch (CompletionException ok) {
2522              checkCompletedWithWrappedCancellationException(h);
2523 <            assertFalse(r.ran());
2523 >            assertEquals(0, r.invocationCount);
2524          }
2525  
2526          checkCancelled(f);
2527          checkCompletedNormally(g, v1);
2528 <        }
2464 <    }
2528 >    }}
2529  
2530      /**
2531       * runAfterEither result completes normally after normal completion
2532       * of either source
2533       */
2534 <    public void testRunAfterEither() {
2535 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2536 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2537 <        Noop r = new Noop();
2538 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2539 <        f.complete(one);
2540 <        checkCompletedNormally(g, null);
2541 <        f2.complete(one);
2542 <        checkCompletedNormally(g, null);
2479 <        assertTrue(r.ran);
2480 <
2481 <        r = new Noop();
2482 <        f = new CompletableFuture<>();
2483 <        f.complete(one);
2484 <        f2 = new CompletableFuture<>();
2485 <        g = f.runAfterEither(f2, r);
2486 <        checkCompletedNormally(g, null);
2487 <        assertTrue(r.ran);
2488 <    }
2489 <
2490 <    /**
2491 <     * runAfterEither result completes exceptionally after exceptional
2492 <     * completion of either source
2493 <     */
2494 <    public void testRunAfterEither2() {
2495 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2496 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2497 <        Noop r = new Noop();
2498 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2499 <        f.completeExceptionally(new CFException());
2500 <        f2.complete(one);
2501 <        checkCompletedWithWrappedCFException(g);
2502 <
2503 <        r = new Noop();
2504 <        f = new CompletableFuture<>();
2505 <        f2 = new CompletableFuture<>();
2506 <        f2.completeExceptionally(new CFException());
2507 <        g = f.runAfterEither(f2, r);
2508 <        checkCompletedWithWrappedCFException(g);
2509 <    }
2534 >    public void testRunAfterEither_normalCompletion1() {
2535 >        for (ExecutionMode m : ExecutionMode.values())
2536 >        for (Integer v1 : new Integer[] { 1, null })
2537 >        for (Integer v2 : new Integer[] { 2, null })
2538 >    {
2539 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2540 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2541 >        final Noop r = new Noop();
2542 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2543  
2544 <    /**
2545 <     * runAfterEither result completes exceptionally if action does
2546 <     */
2547 <    public void testRunAfterEither3() {
2515 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2516 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2517 <        FailingNoop r = new FailingNoop();
2518 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2519 <        f2.complete(two);
2520 <        checkCompletedWithWrappedCFException(g);
2521 <    }
2544 >        f.complete(v1);
2545 >        checkCompletedNormally(h, null);
2546 >        assertEquals(1, r.invocationCount);
2547 >        g.complete(v2);
2548  
2549 <    /**
2550 <     * runAfterEither result completes exceptionally if either source cancelled
2551 <     */
2552 <    public void testRunAfterEither4() {
2553 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2528 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2529 <        Noop r = new Noop();
2530 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2531 <        assertTrue(f.cancel(true));
2532 <        checkCompletedWithWrappedCancellationException(g);
2533 <        f = new CompletableFuture<>();
2534 <        f2 = new CompletableFuture<>();
2535 <        assertTrue(f2.cancel(true));
2536 <        checkCompletedWithWrappedCancellationException(g);
2537 <    }
2549 >        checkCompletedNormally(f, v1);
2550 >        checkCompletedNormally(g, v2);
2551 >        checkCompletedNormally(h, null);
2552 >        assertEquals(1, r.invocationCount);
2553 >    }}
2554  
2555 <    /**
2556 <     * thenCompose result completes normally after normal completion of source
2557 <     */
2558 <    public void testThenCompose() {
2559 <        CompletableFuture<Integer> f, g;
2560 <        CompletableFutureInc r;
2555 >    public void testRunAfterEither_normalCompletion2() {
2556 >        for (ExecutionMode m : ExecutionMode.values())
2557 >        for (Integer v1 : new Integer[] { 1, null })
2558 >        for (Integer v2 : new Integer[] { 2, null })
2559 >    {
2560 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2561 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2562 >        final Noop r = new Noop();
2563 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2564  
2565 <        f = new CompletableFuture<>();
2566 <        g = f.thenCompose(r = new CompletableFutureInc());
2567 <        f.complete(one);
2568 <        checkCompletedNormally(g, two);
2550 <        assertTrue(r.ran);
2565 >        g.complete(v2);
2566 >        checkCompletedNormally(h, null);
2567 >        assertEquals(1, r.invocationCount);
2568 >        f.complete(v1);
2569  
2570 <        f = new CompletableFuture<>();
2571 <        f.complete(one);
2572 <        g = f.thenCompose(r = new CompletableFutureInc());
2573 <        checkCompletedNormally(g, two);
2574 <        assertTrue(r.ran);
2557 <    }
2570 >        checkCompletedNormally(f, v1);
2571 >        checkCompletedNormally(g, v2);
2572 >        checkCompletedNormally(h, null);
2573 >        assertEquals(1, r.invocationCount);
2574 >        }}
2575  
2576 <    /**
2577 <     * thenCompose result completes exceptionally after exceptional
2578 <     * completion of source
2579 <     */
2580 <    public void testThenCompose2() {
2581 <        CompletableFuture<Integer> f, g;
2582 <        CompletableFutureInc r;
2576 >    public void testRunAfterEither_normalCompletion3() {
2577 >        for (ExecutionMode m : ExecutionMode.values())
2578 >        for (Integer v1 : new Integer[] { 1, null })
2579 >        for (Integer v2 : new Integer[] { 2, null })
2580 >    {
2581 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2582 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2583 >        final Noop r = new Noop();
2584  
2585 <        f = new CompletableFuture<>();
2586 <        g = f.thenCompose(r = new CompletableFutureInc());
2587 <        f.completeExceptionally(new CFException());
2570 <        checkCompletedWithWrappedCFException(g);
2585 >        f.complete(v1);
2586 >        g.complete(v2);
2587 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2588  
2589 <        f = new CompletableFuture<>();
2590 <        f.completeExceptionally(new CFException());
2591 <        g = f.thenCompose(r = new CompletableFutureInc());
2592 <        checkCompletedWithWrappedCFException(g);
2593 <    }
2589 >        checkCompletedNormally(h, null);
2590 >        checkCompletedNormally(f, v1);
2591 >        checkCompletedNormally(g, v2);
2592 >        assertEquals(1, r.invocationCount);
2593 >    }}
2594  
2595      /**
2596 <     * thenCompose result completes exceptionally if action does
2596 >     * runAfterEither result completes exceptionally after exceptional
2597 >     * completion of either source
2598       */
2599 <    public void testThenCompose3() {
2600 <        CompletableFuture<Integer> f, g;
2601 <        FailingCompletableFutureFunction r;
2602 <
2603 <        f = new CompletableFuture<>();
2604 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2605 <        f.complete(one);
2606 <        checkCompletedWithWrappedCFException(g);
2599 >    public void testRunAfterEither_exceptionalCompletion1() {
2600 >        for (ExecutionMode m : ExecutionMode.values())
2601 >        for (Integer v1 : new Integer[] { 1, null })
2602 >    {
2603 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2604 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2605 >        final Noop r = new Noop();
2606 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2607 >        final CFException ex = new CFException();
2608  
2609 <        f = new CompletableFuture<>();
2610 <        f.complete(one);
2611 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2593 <        checkCompletedWithWrappedCFException(g);
2594 <    }
2609 >        f.completeExceptionally(ex);
2610 >        checkCompletedWithWrappedCFException(h, ex);
2611 >        g.complete(v1);
2612  
2613 <    /**
2614 <     * thenCompose result completes exceptionally if source cancelled
2615 <     */
2616 <    public void testThenCompose4() {
2617 <        CompletableFuture<Integer> f, g;
2601 <        CompletableFutureInc r;
2613 >        assertEquals(0, r.invocationCount);
2614 >        checkCompletedNormally(g, v1);
2615 >        checkCompletedWithWrappedCFException(f, ex);
2616 >        checkCompletedWithWrappedCFException(h, ex);
2617 >    }}
2618  
2619 <        f = new CompletableFuture<>();
2620 <        g = f.thenCompose(r = new CompletableFutureInc());
2621 <        assertTrue(f.cancel(true));
2622 <        checkCompletedWithWrappedCancellationException(g);
2619 >    public void testRunAfterEither_exceptionalCompletion2() {
2620 >        for (ExecutionMode m : ExecutionMode.values())
2621 >        for (Integer v1 : new Integer[] { 1, null })
2622 >    {
2623 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2624 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2625 >        final Noop r = new Noop();
2626 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2627 >        final CFException ex = new CFException();
2628  
2629 <        f = new CompletableFuture<>();
2630 <        assertTrue(f.cancel(true));
2631 <        g = f.thenCompose(r = new CompletableFutureInc());
2611 <        checkCompletedWithWrappedCancellationException(g);
2612 <    }
2629 >        g.completeExceptionally(ex);
2630 >        checkCompletedWithWrappedCFException(h, ex);
2631 >        f.complete(v1);
2632  
2633 <    // asyncs
2633 >        assertEquals(0, r.invocationCount);
2634 >        checkCompletedNormally(f, v1);
2635 >        checkCompletedWithWrappedCFException(g, ex);
2636 >        checkCompletedWithWrappedCFException(h, ex);
2637 >    }}
2638  
2639 <    /**
2640 <     * thenRunAsync result completes normally after normal completion of source
2641 <     */
2642 <    public void testThenRunAsync() {
2643 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2644 <        Noop r = new Noop();
2645 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2646 <        f.complete(null);
2624 <        checkCompletedNormally(g, null);
2639 >    public void testRunAfterEither_exceptionalCompletion3() {
2640 >        for (ExecutionMode m : ExecutionMode.values())
2641 >        for (Integer v1 : new Integer[] { 1, null })
2642 >    {
2643 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2644 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2645 >        final Noop r = new Noop();
2646 >        final CFException ex = new CFException();
2647  
2648 <        // reordered version
2649 <        f = new CompletableFuture<>();
2650 <        f.complete(null);
2629 <        r = new Noop();
2630 <        g = f.thenRunAsync(r);
2631 <        checkCompletedNormally(g, null);
2632 <    }
2648 >        g.completeExceptionally(ex);
2649 >        f.complete(v1);
2650 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2651  
2652 <    /**
2653 <     * thenRunAsync result completes exceptionally after exceptional
2636 <     * completion of source
2637 <     */
2638 <    public void testThenRunAsync2() {
2639 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2640 <        Noop r = new Noop();
2641 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2642 <        f.completeExceptionally(new CFException());
2652 >        // unspecified behavior
2653 >        Integer v;
2654          try {
2655 <            g.join();
2656 <            shouldThrow();
2657 <        } catch (CompletionException success) {}
2658 <        checkCompletedWithWrappedCFException(g);
2659 <    }
2660 <
2650 <    /**
2651 <     * thenRunAsync result completes exceptionally if action does
2652 <     */
2653 <    public void testThenRunAsync3() {
2654 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2655 <        FailingNoop r = new FailingNoop();
2656 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2657 <        f.complete(null);
2658 <        checkCompletedWithWrappedCFException(g);
2659 <    }
2660 <
2661 <    /**
2662 <     * thenRunAsync result completes exceptionally if source cancelled
2663 <     */
2664 <    public void testThenRunAsync4() {
2665 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2666 <        Noop r = new Noop();
2667 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2668 <        assertTrue(f.cancel(true));
2669 <        checkCompletedWithWrappedCancellationException(g);
2670 <    }
2671 <
2672 <    /**
2673 <     * thenApplyAsync result completes normally after normal completion of source
2674 <     */
2675 <    public void testThenApplyAsync() {
2676 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2677 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2678 <        f.complete(one);
2679 <        checkCompletedNormally(g, two);
2680 <    }
2681 <
2682 <    /**
2683 <     * thenApplyAsync result completes exceptionally after exceptional
2684 <     * completion of source
2685 <     */
2686 <    public void testThenApplyAsync2() {
2687 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2688 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2689 <        f.completeExceptionally(new CFException());
2690 <        checkCompletedWithWrappedCFException(g);
2691 <    }
2692 <
2693 <    /**
2694 <     * thenApplyAsync result completes exceptionally if action does
2695 <     */
2696 <    public void testThenApplyAsync3() {
2697 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2698 <        FailingFunction r = new FailingFunction();
2699 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2700 <        f.complete(null);
2701 <        checkCompletedWithWrappedCFException(g);
2702 <    }
2703 <
2704 <    /**
2705 <     * thenApplyAsync result completes exceptionally if source cancelled
2706 <     */
2707 <    public void testThenApplyAsync4() {
2708 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2709 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2710 <        assertTrue(f.cancel(true));
2711 <        checkCompletedWithWrappedCancellationException(g);
2712 <    }
2713 <
2714 <    /**
2715 <     * thenAcceptAsync result completes normally after normal
2716 <     * completion of source
2717 <     */
2718 <    public void testThenAcceptAsync() {
2719 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2720 <        IncAction r = new IncAction();
2721 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2722 <        f.complete(one);
2723 <        checkCompletedNormally(g, null);
2724 <        assertEquals(r.value, (Integer) 2);
2725 <    }
2726 <
2727 <    /**
2728 <     * thenAcceptAsync result completes exceptionally after exceptional
2729 <     * completion of source
2730 <     */
2731 <    public void testThenAcceptAsync2() {
2732 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2733 <        IncAction r = new IncAction();
2734 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2735 <        f.completeExceptionally(new CFException());
2736 <        checkCompletedWithWrappedCFException(g);
2737 <    }
2738 <
2739 <    /**
2740 <     * thenAcceptAsync result completes exceptionally if action does
2741 <     */
2742 <    public void testThenAcceptAsync3() {
2743 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2744 <        FailingConsumer r = new FailingConsumer();
2745 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2746 <        f.complete(null);
2747 <        checkCompletedWithWrappedCFException(g);
2748 <    }
2749 <
2750 <    /**
2751 <     * thenAcceptAsync result completes exceptionally if source cancelled
2752 <     */
2753 <    public void testThenAcceptAsync4() {
2754 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2755 <        IncAction r = new IncAction();
2756 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2757 <        assertTrue(f.cancel(true));
2758 <        checkCompletedWithWrappedCancellationException(g);
2759 <    }
2760 <
2761 <    /**
2762 <     * runAfterEitherAsync result completes normally after normal
2763 <     * completion of sources
2764 <     */
2765 <    public void testRunAfterEitherAsync() {
2766 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2767 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2768 <        Noop r = new Noop();
2769 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2770 <        f.complete(one);
2771 <        checkCompletedNormally(g, null);
2772 <        assertTrue(r.ran);
2773 <
2774 <        r = new Noop();
2775 <        f = new CompletableFuture<>();
2776 <        f.complete(one);
2777 <        f2 = new CompletableFuture<>();
2778 <        g = f.runAfterEitherAsync(f2, r);
2779 <        checkCompletedNormally(g, null);
2780 <        assertTrue(r.ran);
2781 <    }
2655 >            assertNull(h.join());
2656 >            assertEquals(1, r.invocationCount);
2657 >        } catch (CompletionException ok) {
2658 >            checkCompletedWithWrappedCFException(h, ex);
2659 >            assertEquals(0, r.invocationCount);
2660 >        }
2661  
2662 <    /**
2663 <     * runAfterEitherAsync result completes exceptionally after exceptional
2664 <     * completion of source
2786 <     */
2787 <    public void testRunAfterEitherAsync2() {
2788 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2789 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2790 <        Noop r = new Noop();
2791 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2792 <        f.completeExceptionally(new CFException());
2793 <        checkCompletedWithWrappedCFException(g);
2662 >        checkCompletedWithWrappedCFException(g, ex);
2663 >        checkCompletedNormally(f, v1);
2664 >    }}
2665  
2666 <        r = new Noop();
2667 <        f = new CompletableFuture<>();
2668 <        f2 = new CompletableFuture<>();
2669 <        f2.completeExceptionally(new CFException());
2670 <        g = f.runAfterEitherAsync(f2, r);
2671 <        f.complete(one);
2672 <        checkCompletedWithWrappedCFException(g);
2673 <    }
2666 >    public void testRunAfterEither_exceptionalCompletion4() {
2667 >        for (ExecutionMode m : ExecutionMode.values())
2668 >        for (Integer v1 : new Integer[] { 1, null })
2669 >    {
2670 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2671 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2672 >        final Noop r = new Noop();
2673 >        final CFException ex = new CFException();
2674  
2675 <    /**
2676 <     * runAfterEitherAsync result completes exceptionally if action does
2677 <     */
2807 <    public void testRunAfterEitherAsync3() {
2808 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2809 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2810 <        FailingNoop r = new FailingNoop();
2811 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2812 <        f.complete(one);
2813 <        checkCompletedWithWrappedCFException(g);
2814 <    }
2675 >        f.completeExceptionally(ex);
2676 >        g.complete(v1);
2677 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2678  
2679 <    /**
2680 <     * runAfterEitherAsync result completes exceptionally if either
2681 <     * source cancelled
2682 <     */
2683 <    public void testRunAfterEitherAsync4() {
2684 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2685 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2686 <        Noop r = new Noop();
2687 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2825 <        assertTrue(f.cancel(true));
2826 <        checkCompletedWithWrappedCancellationException(g);
2679 >        // unspecified behavior
2680 >        Integer v;
2681 >        try {
2682 >            assertNull(h.join());
2683 >            assertEquals(1, r.invocationCount);
2684 >        } catch (CompletionException ok) {
2685 >            checkCompletedWithWrappedCFException(h, ex);
2686 >            assertEquals(0, r.invocationCount);
2687 >        }
2688  
2689 <        r = new Noop();
2690 <        f = new CompletableFuture<>();
2691 <        f2 = new CompletableFuture<>();
2831 <        assertTrue(f2.cancel(true));
2832 <        g = f.runAfterEitherAsync(f2, r);
2833 <        checkCompletedWithWrappedCancellationException(g);
2834 <    }
2689 >        checkCompletedWithWrappedCFException(f, ex);
2690 >        checkCompletedNormally(g, v1);
2691 >    }}
2692  
2693      /**
2694 <     * thenComposeAsync result completes normally after normal
2838 <     * completion of source
2694 >     * runAfterEither result completes exceptionally if action does
2695       */
2696 <    public void testThenComposeAsync() {
2697 <        CompletableFuture<Integer> f, g;
2698 <        CompletableFutureInc r;
2699 <
2700 <        f = new CompletableFuture<>();
2701 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2702 <        f.complete(one);
2703 <        checkCompletedNormally(g, two);
2704 <
2849 <        f = new CompletableFuture<>();
2850 <        f.complete(one);
2851 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2852 <        checkCompletedNormally(g, two);
2853 <    }
2696 >    public void testRunAfterEither_actionFailed1() {
2697 >        for (ExecutionMode m : ExecutionMode.values())
2698 >        for (Integer v1 : new Integer[] { 1, null })
2699 >        for (Integer v2 : new Integer[] { 2, null })
2700 >    {
2701 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2702 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2703 >        final FailingRunnable r = new FailingRunnable();
2704 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2705  
2706 <    /**
2707 <     * thenComposeAsync result completes exceptionally after
2708 <     * exceptional completion of source
2709 <     */
2710 <    public void testThenComposeAsync2() {
2711 <        CompletableFuture<Integer> f, g;
2861 <        CompletableFutureInc r;
2706 >        f.complete(v1);
2707 >        checkCompletedWithWrappedCFException(h);
2708 >        g.complete(v2);
2709 >        checkCompletedNormally(f, v1);
2710 >        checkCompletedNormally(g, v2);
2711 >    }}
2712  
2713 <        f = new CompletableFuture<>();
2714 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2715 <        f.completeExceptionally(new CFException());
2716 <        checkCompletedWithWrappedCFException(g);
2717 <        assertFalse(r.ran);
2713 >    public void testRunAfterEither_actionFailed2() {
2714 >        for (ExecutionMode m : ExecutionMode.values())
2715 >        for (Integer v1 : new Integer[] { 1, null })
2716 >        for (Integer v2 : new Integer[] { 2, null })
2717 >    {
2718 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2719 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2720 >        final FailingRunnable r = new FailingRunnable();
2721 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2722  
2723 <        f = new CompletableFuture<>();
2724 <        f.completeExceptionally(new CFException());
2725 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2726 <        checkCompletedWithWrappedCFException(g);
2727 <        assertFalse(r.ran);
2728 <    }
2723 >        g.complete(v2);
2724 >        checkCompletedWithWrappedCFException(h);
2725 >        f.complete(v1);
2726 >        checkCompletedNormally(f, v1);
2727 >        checkCompletedNormally(g, v2);
2728 >    }}
2729  
2730      /**
2731 <     * thenComposeAsync result completes exceptionally if action does
2731 >     * runAfterEither result completes exceptionally if either source cancelled
2732       */
2733 <    public void testThenComposeAsync3() {
2734 <        CompletableFuture<Integer> f, g;
2735 <        FailingCompletableFutureFunction r;
2736 <
2737 <        f = new CompletableFuture<>();
2738 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2739 <        f.complete(one);
2740 <        checkCompletedWithWrappedCFException(g);
2733 >    public void testRunAfterEither_sourceCancelled1() {
2734 >        for (ExecutionMode m : ExecutionMode.values())
2735 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2736 >        for (Integer v1 : new Integer[] { 1, null })
2737 >    {
2738 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2739 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2740 >        final Noop r = new Noop();
2741 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2742  
2743 <        f = new CompletableFuture<>();
2744 <        f.complete(one);
2745 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2891 <        checkCompletedWithWrappedCFException(g);
2892 <    }
2743 >        assertTrue(f.cancel(mayInterruptIfRunning));
2744 >        checkCompletedWithWrappedCancellationException(h);
2745 >        g.complete(v1);
2746  
2747 <    /**
2748 <     * thenComposeAsync result completes exceptionally if source cancelled
2749 <     */
2750 <    public void testThenComposeAsync4() {
2751 <        CompletableFuture<Integer> f, g;
2899 <        CompletableFutureInc r;
2747 >        checkCancelled(f);
2748 >        assertEquals(0, r.invocationCount);
2749 >        checkCompletedNormally(g, v1);
2750 >        checkCompletedWithWrappedCancellationException(h);
2751 >    }}
2752  
2753 <        f = new CompletableFuture<>();
2754 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2755 <        assertTrue(f.cancel(true));
2756 <        checkCompletedWithWrappedCancellationException(g);
2753 >    public void testRunAfterEither_sourceCancelled2() {
2754 >        for (ExecutionMode m : ExecutionMode.values())
2755 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2756 >        for (Integer v1 : new Integer[] { 1, null })
2757 >    {
2758 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2759 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2760 >        final Noop r = new Noop();
2761 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2762  
2763 <        f = new CompletableFuture<>();
2764 <        assertTrue(f.cancel(true));
2765 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2909 <        checkCompletedWithWrappedCancellationException(g);
2910 <    }
2763 >        assertTrue(g.cancel(mayInterruptIfRunning));
2764 >        checkCompletedWithWrappedCancellationException(h);
2765 >        f.complete(v1);
2766  
2767 <    // async with explicit executors
2767 >        checkCancelled(g);
2768 >        assertEquals(0, r.invocationCount);
2769 >        checkCompletedNormally(f, v1);
2770 >        checkCompletedWithWrappedCancellationException(h);
2771 >    }}
2772  
2773 <    /**
2774 <     * thenRunAsync result completes normally after normal completion of source
2775 <     */
2776 <    public void testThenRunAsyncE() {
2777 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2778 <        Noop r = new Noop();
2779 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2780 <        f.complete(null);
2922 <        checkCompletedNormally(g, null);
2773 >    public void testRunAfterEither_sourceCancelled3() {
2774 >        for (ExecutionMode m : ExecutionMode.values())
2775 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2776 >        for (Integer v1 : new Integer[] { 1, null })
2777 >    {
2778 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2779 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2780 >        final Noop r = new Noop();
2781  
2782 <        // reordered version
2783 <        f = new CompletableFuture<>();
2784 <        f.complete(null);
2927 <        r = new Noop();
2928 <        g = f.thenRunAsync(r, new ThreadExecutor());
2929 <        checkCompletedNormally(g, null);
2930 <    }
2782 >        assertTrue(g.cancel(mayInterruptIfRunning));
2783 >        f.complete(v1);
2784 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2785  
2786 <    /**
2787 <     * thenRunAsync result completes exceptionally after exceptional
2934 <     * completion of source
2935 <     */
2936 <    public void testThenRunAsync2E() {
2937 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2938 <        Noop r = new Noop();
2939 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2940 <        f.completeExceptionally(new CFException());
2786 >        // unspecified behavior
2787 >        Integer v;
2788          try {
2789 <            g.join();
2790 <            shouldThrow();
2791 <        } catch (CompletionException success) {}
2792 <        checkCompletedWithWrappedCFException(g);
2793 <    }
2794 <
2948 <    /**
2949 <     * thenRunAsync result completes exceptionally if action does
2950 <     */
2951 <    public void testThenRunAsync3E() {
2952 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2953 <        FailingNoop r = new FailingNoop();
2954 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2955 <        f.complete(null);
2956 <        checkCompletedWithWrappedCFException(g);
2957 <    }
2958 <
2959 <    /**
2960 <     * thenRunAsync result completes exceptionally if source cancelled
2961 <     */
2962 <    public void testThenRunAsync4E() {
2963 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2964 <        Noop r = new Noop();
2965 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2966 <        assertTrue(f.cancel(true));
2967 <        checkCompletedWithWrappedCancellationException(g);
2968 <    }
2969 <
2970 <    /**
2971 <     * thenApplyAsync result completes normally after normal completion of source
2972 <     */
2973 <    public void testThenApplyAsyncE() {
2974 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2975 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2976 <        f.complete(one);
2977 <        checkCompletedNormally(g, two);
2978 <    }
2979 <
2980 <    /**
2981 <     * thenApplyAsync result completes exceptionally after exceptional
2982 <     * completion of source
2983 <     */
2984 <    public void testThenApplyAsync2E() {
2985 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2986 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2987 <        f.completeExceptionally(new CFException());
2988 <        checkCompletedWithWrappedCFException(g);
2989 <    }
2990 <
2991 <    /**
2992 <     * thenApplyAsync result completes exceptionally if action does
2993 <     */
2994 <    public void testThenApplyAsync3E() {
2995 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2996 <        FailingFunction r = new FailingFunction();
2997 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2998 <        f.complete(null);
2999 <        checkCompletedWithWrappedCFException(g);
3000 <    }
2789 >            assertNull(h.join());
2790 >            assertEquals(1, r.invocationCount);
2791 >        } catch (CompletionException ok) {
2792 >            checkCompletedWithWrappedCancellationException(h);
2793 >            assertEquals(0, r.invocationCount);
2794 >        }
2795  
2796 <    /**
2797 <     * thenApplyAsync result completes exceptionally if source cancelled
2798 <     */
3005 <    public void testThenApplyAsync4E() {
3006 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3007 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3008 <        assertTrue(f.cancel(true));
3009 <        checkCompletedWithWrappedCancellationException(g);
3010 <    }
2796 >        checkCancelled(g);
2797 >        checkCompletedNormally(f, v1);
2798 >    }}
2799  
2800 <    /**
2801 <     * thenAcceptAsync result completes normally after normal
2802 <     * completion of source
2803 <     */
2804 <    public void testThenAcceptAsyncE() {
2805 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2806 <        IncAction r = new IncAction();
2807 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3020 <        f.complete(one);
3021 <        checkCompletedNormally(g, null);
3022 <        assertEquals(r.value, (Integer) 2);
3023 <    }
2800 >    public void testRunAfterEither_sourceCancelled4() {
2801 >        for (ExecutionMode m : ExecutionMode.values())
2802 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2803 >        for (Integer v1 : new Integer[] { 1, null })
2804 >    {
2805 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2806 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2807 >        final Noop r = new Noop();
2808  
2809 <    /**
2810 <     * thenAcceptAsync result completes exceptionally after exceptional
2811 <     * completion of source
3028 <     */
3029 <    public void testThenAcceptAsync2E() {
3030 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3031 <        IncAction r = new IncAction();
3032 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3033 <        f.completeExceptionally(new CFException());
3034 <        checkCompletedWithWrappedCFException(g);
3035 <    }
2809 >        assertTrue(f.cancel(mayInterruptIfRunning));
2810 >        g.complete(v1);
2811 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2812  
2813 <    /**
2814 <     * thenAcceptAsync result completes exceptionally if action does
2815 <     */
2816 <    public void testThenAcceptAsync3E() {
2817 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2818 <        FailingConsumer r = new FailingConsumer();
2819 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2820 <        f.complete(null);
2821 <        checkCompletedWithWrappedCFException(g);
3046 <    }
2813 >        // unspecified behavior
2814 >        Integer v;
2815 >        try {
2816 >            assertNull(h.join());
2817 >            assertEquals(1, r.invocationCount);
2818 >        } catch (CompletionException ok) {
2819 >            checkCompletedWithWrappedCancellationException(h);
2820 >            assertEquals(0, r.invocationCount);
2821 >        }
2822  
2823 <    /**
2824 <     * thenAcceptAsync result completes exceptionally if source cancelled
2825 <     */
3051 <    public void testThenAcceptAsync4E() {
3052 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3053 <        IncAction r = new IncAction();
3054 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3055 <        assertTrue(f.cancel(true));
3056 <        checkCompletedWithWrappedCancellationException(g);
3057 <    }
2823 >        checkCancelled(f);
2824 >        checkCompletedNormally(g, v1);
2825 >    }}
2826  
2827      /**
2828 <     * runAfterEitherAsync result completes normally after normal
3061 <     * completion of sources
2828 >     * thenCompose result completes normally after normal completion of source
2829       */
2830 <    public void testRunAfterEitherAsyncE() {
2831 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2832 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2833 <        Noop r = new Noop();
2834 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2835 <        f.complete(one);
2836 <        checkCompletedNormally(g, null);
2837 <        assertTrue(r.ran);
2830 >    public void testThenCompose_normalCompletion() {
2831 >        for (ExecutionMode m : ExecutionMode.values())
2832 >        for (boolean createIncomplete : new boolean[] { true, false })
2833 >        for (Integer v1 : new Integer[] { 1, null })
2834 >    {
2835 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2836 >        final CompletableFutureInc r = new CompletableFutureInc();
2837 >        if (!createIncomplete) f.complete(v1);
2838 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2839 >        if (createIncomplete) f.complete(v1);
2840  
2841 <        r = new Noop();
2842 <        f = new CompletableFuture<>();
2843 <        f.complete(one);
2844 <        f2 = new CompletableFuture<>();
3076 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3077 <        checkCompletedNormally(g, null);
3078 <        assertTrue(r.ran);
3079 <    }
2841 >        checkCompletedNormally(g, inc(v1));
2842 >        checkCompletedNormally(f, v1);
2843 >        assertEquals(1, r.invocationCount);
2844 >    }}
2845  
2846      /**
2847 <     * runAfterEitherAsync result completes exceptionally after exceptional
2847 >     * thenCompose result completes exceptionally after exceptional
2848       * completion of source
2849       */
2850 <    public void testRunAfterEitherAsync2E() {
2851 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2852 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2853 <        Noop r = new Noop();
2854 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2855 <        f.completeExceptionally(new CFException());
2856 <        checkCompletedWithWrappedCFException(g);
2857 <
2858 <        r = new Noop();
2859 <        f = new CompletableFuture<>();
3095 <        f2 = new CompletableFuture<>();
3096 <        f2.completeExceptionally(new CFException());
3097 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3098 <        f.complete(one);
3099 <        checkCompletedWithWrappedCFException(g);
3100 <    }
3101 <
3102 <    /**
3103 <     * runAfterEitherAsync result completes exceptionally if action does
3104 <     */
3105 <    public void testRunAfterEitherAsync3E() {
3106 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3107 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
3108 <        FailingNoop r = new FailingNoop();
3109 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3110 <        f.complete(one);
3111 <        checkCompletedWithWrappedCFException(g);
3112 <    }
3113 <
3114 <    /**
3115 <     * runAfterEitherAsync result completes exceptionally if either
3116 <     * source cancelled
3117 <     */
3118 <    public void testRunAfterEitherAsync4E() {
3119 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3120 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
3121 <        Noop r = new Noop();
3122 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3123 <        assertTrue(f.cancel(true));
3124 <        checkCompletedWithWrappedCancellationException(g);
2850 >    public void testThenCompose_exceptionalCompletion() {
2851 >        for (ExecutionMode m : ExecutionMode.values())
2852 >        for (boolean createIncomplete : new boolean[] { true, false })
2853 >    {
2854 >        final CFException ex = new CFException();
2855 >        final CompletableFutureInc r = new CompletableFutureInc();
2856 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2857 >        if (!createIncomplete) f.completeExceptionally(ex);
2858 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2859 >        if (createIncomplete) f.completeExceptionally(ex);
2860  
2861 <        r = new Noop();
2862 <        f = new CompletableFuture<>();
2863 <        f2 = new CompletableFuture<>();
2864 <        assertTrue(f2.cancel(true));
3130 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3131 <        checkCompletedWithWrappedCancellationException(g);
3132 <    }
2861 >        checkCompletedWithWrappedCFException(g, ex);
2862 >        checkCompletedWithWrappedCFException(f, ex);
2863 >        assertEquals(0, r.invocationCount);
2864 >    }}
2865  
2866      /**
2867 <     * thenComposeAsync result completes normally after normal
3136 <     * completion of source
2867 >     * thenCompose result completes exceptionally if action does
2868       */
2869 <    public void testThenComposeAsyncE() {
2870 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2871 <        CompletableFutureInc r = new CompletableFutureInc();
2872 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2873 <        f.complete(one);
2874 <        checkCompletedNormally(g, two);
2875 <    }
2869 >    public void testThenCompose_actionFailed() {
2870 >        for (ExecutionMode m : ExecutionMode.values())
2871 >        for (boolean createIncomplete : new boolean[] { true, false })
2872 >        for (Integer v1 : new Integer[] { 1, null })
2873 >    {
2874 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2875 >        final FailingCompletableFutureFunction r
2876 >            = new FailingCompletableFutureFunction();
2877 >        if (!createIncomplete) f.complete(v1);
2878 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2879 >        if (createIncomplete) f.complete(v1);
2880  
3146    /**
3147     * thenComposeAsync result completes exceptionally after
3148     * exceptional completion of source
3149     */
3150    public void testThenComposeAsync2E() {
3151        CompletableFuture<Integer> f = new CompletableFuture<>();
3152        CompletableFutureInc r = new CompletableFutureInc();
3153        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3154        f.completeExceptionally(new CFException());
2881          checkCompletedWithWrappedCFException(g);
2882 <    }
2882 >        checkCompletedNormally(f, v1);
2883 >    }}
2884  
2885      /**
2886 <     * thenComposeAsync result completes exceptionally if action does
2886 >     * thenCompose result completes exceptionally if source cancelled
2887       */
2888 <    public void testThenComposeAsync3E() {
2889 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2890 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2891 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2892 <        f.complete(one);
2893 <        checkCompletedWithWrappedCFException(g);
2894 <    }
2888 >    public void testThenCompose_sourceCancelled() {
2889 >        for (ExecutionMode m : ExecutionMode.values())
2890 >        for (boolean createIncomplete : new boolean[] { true, false })
2891 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2892 >    {
2893 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2894 >        final CompletableFutureInc r = new CompletableFutureInc();
2895 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2896 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2897 >        if (createIncomplete) {
2898 >            checkIncomplete(g);
2899 >            assertTrue(f.cancel(mayInterruptIfRunning));
2900 >        }
2901  
3169    /**
3170     * thenComposeAsync result completes exceptionally if source cancelled
3171     */
3172    public void testThenComposeAsync4E() {
3173        CompletableFuture<Integer> f = new CompletableFuture<>();
3174        CompletableFutureInc r = new CompletableFutureInc();
3175        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3176        assertTrue(f.cancel(true));
2902          checkCompletedWithWrappedCancellationException(g);
2903 <    }
2903 >        checkCancelled(f);
2904 >    }}
2905  
2906      // other static methods
2907  
# Line 3375 | Line 3101 | public class CompletableFutureTest exten
3101       * whenComplete action executes on normal completion, propagating
3102       * source result.
3103       */
3104 <    public void testWhenComplete1() {
3105 <        final AtomicInteger a = new AtomicInteger();
3106 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3107 <        CompletableFuture<Integer> g =
3108 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3109 <        f.complete(three);
3110 <        checkCompletedNormally(f, three);
3111 <        checkCompletedNormally(g, three);
3112 <        assertEquals(a.get(), 1);
3113 <    }
3114 <
3115 <    /**
3116 <     * whenComplete action executes on exceptional completion, propagating
3117 <     * source result.
3118 <     */
3119 <    public void testWhenComplete2() {
3394 <        final AtomicInteger a = new AtomicInteger();
3395 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3396 <        CompletableFuture<Integer> g =
3397 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3398 <        f.completeExceptionally(new CFException());
3399 <        assertTrue(f.isCompletedExceptionally());
3400 <        assertTrue(g.isCompletedExceptionally());
3401 <        assertEquals(a.get(), 1);
3402 <    }
3403 <
3404 <    /**
3405 <     * If a whenComplete action throws an exception when triggered by
3406 <     * a normal completion, it completes exceptionally
3407 <     */
3408 <    public void testWhenComplete3() {
3409 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3410 <        CompletableFuture<Integer> g =
3411 <            f.whenComplete((Integer x, Throwable t) ->
3412 <                           { throw new CFException(); } );
3413 <        f.complete(three);
3414 <        checkCompletedNormally(f, three);
3415 <        assertTrue(g.isCompletedExceptionally());
3416 <        checkCompletedWithWrappedCFException(g);
3417 <    }
3418 <
3419 <    /**
3420 <     * whenCompleteAsync action executes on normal completion, propagating
3421 <     * source result.
3422 <     */
3423 <    public void testWhenCompleteAsync1() {
3424 <        final AtomicInteger a = new AtomicInteger();
3425 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3426 <        CompletableFuture<Integer> g =
3427 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3428 <        f.complete(three);
3429 <        checkCompletedNormally(f, three);
3430 <        checkCompletedNormally(g, three);
3431 <        assertEquals(a.get(), 1);
3432 <    }
3433 <
3434 <    /**
3435 <     * whenCompleteAsync action executes on exceptional completion, propagating
3436 <     * source result.
3437 <     */
3438 <    public void testWhenCompleteAsync2() {
3439 <        final AtomicInteger a = new AtomicInteger();
3440 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3441 <        CompletableFuture<Integer> g =
3442 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3443 <        f.completeExceptionally(new CFException());
3444 <        checkCompletedWithWrappedCFException(f);
3445 <        checkCompletedWithWrappedCFException(g);
3446 <    }
3104 >    public void testWhenComplete_normalCompletion1() {
3105 >        for (ExecutionMode m : ExecutionMode.values())
3106 >        for (boolean createIncomplete : new boolean[] { true, false })
3107 >        for (Integer v1 : new Integer[] { 1, null })
3108 >    {
3109 >        final AtomicInteger a = new AtomicInteger(0);
3110 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3111 >        if (!createIncomplete) f.complete(v1);
3112 >        final CompletableFuture<Integer> g = m.whenComplete
3113 >            (f,
3114 >             (Integer x, Throwable t) -> {
3115 >                threadAssertSame(x, v1);
3116 >                threadAssertNull(t);
3117 >                a.getAndIncrement();
3118 >            });
3119 >        if (createIncomplete) f.complete(v1);
3120  
3121 <    /**
3122 <     * If a whenCompleteAsync action throws an exception when
3123 <     * triggered by a normal completion, it completes exceptionally
3124 <     */
3452 <    public void testWhenCompleteAsync3() {
3453 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3454 <        CompletableFuture<Integer> g =
3455 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3456 <                           { throw new CFException(); } );
3457 <        f.complete(three);
3458 <        checkCompletedNormally(f, three);
3459 <        checkCompletedWithWrappedCFException(g);
3460 <    }
3121 >        checkCompletedNormally(g, v1);
3122 >        checkCompletedNormally(f, v1);
3123 >        assertEquals(1, a.get());
3124 >    }}
3125  
3126      /**
3127 <     * whenCompleteAsync action executes on normal completion, propagating
3127 >     * whenComplete action executes on exceptional completion, propagating
3128       * source result.
3129       */
3130 <    public void testWhenCompleteAsync1e() {
3131 <        final AtomicInteger a = new AtomicInteger();
3132 <        ThreadExecutor exec = new ThreadExecutor();
3133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3134 <        CompletableFuture<Integer> g =
3135 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3136 <                                exec);
3137 <        f.complete(three);
3138 <        checkCompletedNormally(f, three);
3139 <        checkCompletedNormally(g, three);
3140 <        assertEquals(a.get(), 1);
3141 <    }
3130 >    public void testWhenComplete_exceptionalCompletion() {
3131 >        for (ExecutionMode m : ExecutionMode.values())
3132 >        for (boolean createIncomplete : new boolean[] { true, false })
3133 >        for (Integer v1 : new Integer[] { 1, null })
3134 >    {
3135 >        final AtomicInteger a = new AtomicInteger(0);
3136 >        final CFException ex = new CFException();
3137 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3138 >        if (!createIncomplete) f.completeExceptionally(ex);
3139 >        final CompletableFuture<Integer> g = m.whenComplete
3140 >            (f,
3141 >             (Integer x, Throwable t) -> {
3142 >                threadAssertNull(x);
3143 >                threadAssertSame(t, ex);
3144 >                a.getAndIncrement();
3145 >            });
3146 >        if (createIncomplete) f.completeExceptionally(ex);
3147 >        checkCompletedWithWrappedCFException(f, ex);
3148 >        checkCompletedWithWrappedCFException(g, ex);
3149 >        assertEquals(1, a.get());
3150 >    }}
3151  
3152      /**
3153 <     * whenCompleteAsync action executes on exceptional completion, propagating
3154 <     * source result.
3153 >     * whenComplete action executes on cancelled source, propagating
3154 >     * CancellationException.
3155       */
3156 <    public void testWhenCompleteAsync2e() {
3157 <        final AtomicInteger a = new AtomicInteger();
3158 <        ThreadExecutor exec = new ThreadExecutor();
3159 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3160 <        CompletableFuture<Integer> g =
3161 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3162 <                                exec);
3163 <        f.completeExceptionally(new CFException());
3164 <        checkCompletedWithWrappedCFException(f);
3165 <        checkCompletedWithWrappedCFException(g);
3166 <    }
3156 >    public void testWhenComplete_sourceCancelled() {
3157 >        for (ExecutionMode m : ExecutionMode.values())
3158 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3159 >        for (boolean createIncomplete : new boolean[] { true, false })
3160 >    {
3161 >        final AtomicInteger a = new AtomicInteger(0);
3162 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3163 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3164 >        final CompletableFuture<Integer> g = m.whenComplete
3165 >            (f,
3166 >             (Integer x, Throwable t) -> {
3167 >                threadAssertNull(x);
3168 >                threadAssertTrue(t instanceof CancellationException);
3169 >                a.getAndIncrement();
3170 >            });
3171 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3172  
3173 <    /**
3174 <     * If a whenCompleteAsync action throws an exception when triggered
3175 <     * by a normal completion, it completes exceptionally
3176 <     */
3177 <    public void testWhenCompleteAsync3e() {
3500 <        ThreadExecutor exec = new ThreadExecutor();
3501 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3502 <        CompletableFuture<Integer> g =
3503 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3504 <                                { throw new CFException(); },
3505 <                                exec);
3506 <        f.complete(three);
3507 <        checkCompletedNormally(f, three);
3508 <        checkCompletedWithWrappedCFException(g);
3509 <    }
3173 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
3174 >        checkCompletedWithWrappedCancellationException(g);
3175 >        checkCancelled(f);
3176 >        assertEquals(1, a.get());
3177 >    }}
3178  
3179      /**
3180 <     * handleAsync action completes normally with function value on
3181 <     * either normal or exceptional completion of source
3180 >     * If a whenComplete action throws an exception when triggered by
3181 >     * a normal completion, it completes exceptionally
3182       */
3183 <    public void testHandleAsync() {
3184 <        CompletableFuture<Integer> f, g;
3185 <        IntegerHandler r;
3186 <
3187 <        f = new CompletableFuture<>();
3188 <        g = f.handleAsync(r = new IntegerHandler());
3189 <        assertFalse(r.ran);
3190 <        f.completeExceptionally(new CFException());
3191 <        checkCompletedWithWrappedCFException(f);
3192 <        checkCompletedNormally(g, three);
3193 <        assertTrue(r.ran);
3194 <
3195 <        f = new CompletableFuture<>();
3196 <        g = f.handleAsync(r = new IntegerHandler());
3197 <        assertFalse(r.ran);
3198 <        f.completeExceptionally(new CFException());
3199 <        checkCompletedWithWrappedCFException(f);
3200 <        checkCompletedNormally(g, three);
3201 <        assertTrue(r.ran);
3202 <
3203 <        f = new CompletableFuture<>();
3204 <        g = f.handleAsync(r = new IntegerHandler());
3537 <        assertFalse(r.ran);
3538 <        f.complete(one);
3539 <        checkCompletedNormally(f, one);
3540 <        checkCompletedNormally(g, two);
3541 <        assertTrue(r.ran);
3542 <
3543 <        f = new CompletableFuture<>();
3544 <        g = f.handleAsync(r = new IntegerHandler());
3545 <        assertFalse(r.ran);
3546 <        f.complete(one);
3547 <        checkCompletedNormally(f, one);
3548 <        checkCompletedNormally(g, two);
3549 <        assertTrue(r.ran);
3550 <    }
3183 >    public void testWhenComplete_actionFailed() {
3184 >        for (boolean createIncomplete : new boolean[] { true, false })
3185 >        for (ExecutionMode m : ExecutionMode.values())
3186 >        for (Integer v1 : new Integer[] { 1, null })
3187 >    {
3188 >        final AtomicInteger a = new AtomicInteger(0);
3189 >        final CFException ex = new CFException();
3190 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3191 >        if (!createIncomplete) f.complete(v1);
3192 >        final CompletableFuture<Integer> g = m.whenComplete
3193 >            (f,
3194 >             (Integer x, Throwable t) -> {
3195 >                threadAssertSame(x, v1);
3196 >                threadAssertNull(t);
3197 >                a.getAndIncrement();
3198 >                throw ex;
3199 >            });
3200 >        if (createIncomplete) f.complete(v1);
3201 >        checkCompletedNormally(f, v1);
3202 >        checkCompletedWithWrappedCFException(g, ex);
3203 >        assertEquals(1, a.get());
3204 >    }}
3205  
3206      /**
3207 <     * handleAsync action with Executor completes normally with
3208 <     * function value on either normal or exceptional completion of
3209 <     * source
3207 >     * If a whenComplete action throws an exception when triggered by
3208 >     * a source completion that also throws an exception, the source
3209 >     * exception takes precedence.
3210       */
3211 <    public void testHandleAsync2() {
3212 <        CompletableFuture<Integer> f, g;
3213 <        ThreadExecutor exec = new ThreadExecutor();
3214 <        IntegerHandler r;
3215 <
3216 <        f = new CompletableFuture<>();
3217 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3218 <        assertFalse(r.ran);
3219 <        f.completeExceptionally(new CFException());
3220 <        checkCompletedWithWrappedCFException(f);
3221 <        checkCompletedNormally(g, three);
3222 <        assertTrue(r.ran);
3223 <
3224 <        f = new CompletableFuture<>();
3225 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3226 <        assertFalse(r.ran);
3227 <        f.completeExceptionally(new CFException());
3228 <        checkCompletedWithWrappedCFException(f);
3229 <        checkCompletedNormally(g, three);
3230 <        assertTrue(r.ran);
3231 <
3232 <        f = new CompletableFuture<>();
3233 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3234 <        assertFalse(r.ran);
3235 <        f.complete(one);
3582 <        checkCompletedNormally(f, one);
3583 <        checkCompletedNormally(g, two);
3584 <        assertTrue(r.ran);
3585 <
3586 <        f = new CompletableFuture<>();
3587 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3588 <        assertFalse(r.ran);
3589 <        f.complete(one);
3590 <        checkCompletedNormally(f, one);
3591 <        checkCompletedNormally(g, two);
3592 <        assertTrue(r.ran);
3593 <    }
3211 >    public void testWhenComplete_actionFailedSourceFailed() {
3212 >        for (boolean createIncomplete : new boolean[] { true, false })
3213 >        for (ExecutionMode m : ExecutionMode.values())
3214 >        for (Integer v1 : new Integer[] { 1, null })
3215 >    {
3216 >        final AtomicInteger a = new AtomicInteger(0);
3217 >        final CFException ex1 = new CFException();
3218 >        final CFException ex2 = new CFException();
3219 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3220 >
3221 >        if (!createIncomplete) f.completeExceptionally(ex1);
3222 >        final CompletableFuture<Integer> g = m.whenComplete
3223 >            (f,
3224 >             (Integer x, Throwable t) -> {
3225 >                threadAssertSame(t, ex1);
3226 >                threadAssertNull(x);
3227 >                a.getAndIncrement();
3228 >                throw ex2;
3229 >            });
3230 >        if (createIncomplete) f.completeExceptionally(ex1);
3231 >
3232 >        checkCompletedWithWrappedCFException(f, ex1);
3233 >        checkCompletedWithWrappedCFException(g, ex1);
3234 >        assertEquals(1, a.get());
3235 >    }}
3236  
3237   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines