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.42 by jsr166, Mon Jun 2 02:19:23 2014 UTC vs.
Revision 1.53 by jsr166, Mon Jun 2 20:20:47 2014 UTC

# Line 17 | Line 17 | import java.util.concurrent.Future;
17   import java.util.concurrent.CompletableFuture;
18   import java.util.concurrent.CompletionException;
19   import java.util.concurrent.CompletionStage;
20 + import java.util.concurrent.ForkJoinPool;
21 + import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.TimeoutException;
23   import java.util.concurrent.atomic.AtomicInteger;
24   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 247 | Line 249 | public class CompletableFutureTest exten
249          f = new CompletableFuture<>();
250          f.obtrudeValue(three);
251          checkCompletedNormally(f, three);
252 +        f.obtrudeValue(null);
253 +        checkCompletedNormally(f, null);
254          f = new CompletableFuture<>();
255          f.completeExceptionally(new CFException());
256          f.obtrudeValue(four);
# Line 279 | Line 283 | public class CompletableFutureTest exten
283       */
284      public void testGetNumberOfDependents() {
285          CompletableFuture<Integer> f = new CompletableFuture<>();
286 <        assertEquals(f.getNumberOfDependents(), 0);
286 >        assertEquals(0, f.getNumberOfDependents());
287          CompletableFuture g = f.thenRun(new Noop());
288 <        assertEquals(f.getNumberOfDependents(), 1);
289 <        assertEquals(g.getNumberOfDependents(), 0);
288 >        assertEquals(1, f.getNumberOfDependents());
289 >        assertEquals(0, g.getNumberOfDependents());
290          CompletableFuture h = f.thenRun(new Noop());
291 <        assertEquals(f.getNumberOfDependents(), 2);
291 >        assertEquals(2, f.getNumberOfDependents());
292          f.complete(1);
293          checkCompletedNormally(g, null);
294 <        assertEquals(f.getNumberOfDependents(), 0);
295 <        assertEquals(g.getNumberOfDependents(), 0);
294 >        assertEquals(0, f.getNumberOfDependents());
295 >        assertEquals(0, g.getNumberOfDependents());
296      }
297  
298      /**
# Line 339 | Line 343 | public class CompletableFutureTest exten
343      static final class IncAction implements Consumer<Integer> {
344          int invocationCount = 0;
345          Integer value;
342 –        public boolean ran() { return invocationCount == 1; }
346          public void accept(Integer x) {
347              invocationCount++;
348              value = inc(x);
# Line 348 | Line 351 | public class CompletableFutureTest exten
351      static final class IncFunction implements Function<Integer,Integer> {
352          int invocationCount = 0;
353          Integer value;
351 –        public boolean ran() { return invocationCount == 1; }
354          public Integer apply(Integer x) {
355              invocationCount++;
356              return value = inc(x);
# Line 358 | Line 360 | public class CompletableFutureTest exten
360          int invocationCount = 0;
361          Integer value;
362          // Check this action was invoked exactly once when result is computed.
361 –        public boolean ran() { return invocationCount == 1; }
363          public void accept(Integer x, Integer y) {
364              invocationCount++;
365              value = subtract(x, y);
# Line 368 | Line 369 | public class CompletableFutureTest exten
369          int invocationCount = 0;
370          Integer value;
371          // Check this action was invoked exactly once when result is computed.
371 –        public boolean ran() { return invocationCount == 1; }
372          public Integer apply(Integer x, Integer y) {
373              invocationCount++;
374              return value = subtract(x, y);
# Line 376 | Line 376 | public class CompletableFutureTest exten
376      }
377      static final class Noop implements Runnable {
378          int invocationCount = 0;
379 –        boolean ran;
379          public void run() {
380              invocationCount++;
382 –            ran = true;
381          }
382      }
383  
384      static final class FailingSupplier implements Supplier<Integer> {
385 <        boolean ran;
386 <        public Integer get() { ran = true; throw new CFException(); }
385 >        int invocationCount = 0;
386 >        public Integer get() {
387 >            invocationCount++;
388 >            throw new CFException();
389 >        }
390      }
391      static final class FailingConsumer implements Consumer<Integer> {
392 <        boolean ran;
393 <        public void accept(Integer x) { ran = true; throw new CFException(); }
392 >        int invocationCount = 0;
393 >        public void accept(Integer x) {
394 >            invocationCount++;
395 >            throw new CFException();
396 >        }
397      }
398      static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
399 <        boolean ran;
400 <        public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
399 >        int invocationCount = 0;
400 >        public void accept(Integer x, Integer y) {
401 >            invocationCount++;
402 >            throw new CFException();
403 >        }
404      }
405      static final class FailingFunction implements Function<Integer, Integer> {
406 <        boolean ran;
407 <        public Integer apply(Integer x) { ran = true; throw new CFException(); }
406 >        int invocationCount = 0;
407 >        public Integer apply(Integer x) {
408 >            invocationCount++;
409 >            throw new CFException();
410 >        }
411      }
412      static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
413 <        boolean ran;
414 <        public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
413 >        int invocationCount = 0;
414 >        public Integer apply(Integer x, Integer y) {
415 >            invocationCount++;
416 >            throw new CFException();
417 >        }
418      }
419 <    static final class FailingNoop implements Runnable {
420 <        boolean ran;
421 <        public void run() { ran = true; throw new CFException(); }
419 >    static final class FailingRunnable implements Runnable {
420 >        int invocationCount = 0;
421 >        public void run() {
422 >            invocationCount++;
423 >            throw new CFException();
424 >        }
425      }
426  
427      static final class CompletableFutureInc
428          implements Function<Integer, CompletableFuture<Integer>> {
429 <        boolean ran;
429 >        int invocationCount = 0;
430          public CompletableFuture<Integer> apply(Integer x) {
431 <            ran = true;
431 >            invocationCount++;
432              CompletableFuture<Integer> f = new CompletableFuture<>();
433 <            f.complete(Integer.valueOf(x.intValue() + 1));
433 >            f.complete(inc(x));
434              return f;
435          }
436      }
437  
438      static final class FailingCompletableFutureFunction
439          implements Function<Integer, CompletableFuture<Integer>> {
440 <        boolean ran;
440 >        int invocationCount = 0;
441          public CompletableFuture<Integer> apply(Integer x) {
442 <            ran = true; throw new CFException();
442 >            invocationCount++;
443 >            throw new CFException();
444          }
445      }
446  
# Line 437 | Line 454 | public class CompletableFutureTest exten
454          }
455      }
456  
440 –    static final class ExceptionToInteger implements Function<Throwable, Integer> {
441 –        public Integer apply(Throwable x) { return Integer.valueOf(3); }
442 –    }
443 –
444 –    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
445 –        boolean ran;
446 –        public Integer apply(Integer x, Throwable t) {
447 –            ran = true;
448 –            return (t == null) ? two : three;
449 –        }
450 –    }
451 –
457      /**
458       * Permits the testing of parallel code for the 3 different
459       * execution modes without repeating all the testing code.
460       */
461      enum ExecutionMode {
462          DEFAULT {
463 +            public void checkExecutionMode() {
464 +                assertNull(ForkJoinTask.getPool());
465 +            }
466 +            public <T> CompletableFuture<Void> thenRun
467 +                (CompletableFuture<T> f, Runnable a) {
468 +                return f.thenRun(a);
469 +            }
470 +            public <T> CompletableFuture<Void> thenAccept
471 +                (CompletableFuture<T> f, Consumer<? super T> a) {
472 +                return f.thenAccept(a);
473 +            }
474 +            public <T,U> CompletableFuture<U> thenApply
475 +                (CompletableFuture<T> f, Function<? super T,U> a) {
476 +                return f.thenApply(a);
477 +            }
478 +            public <T,U> CompletableFuture<U> thenCompose
479 +                (CompletableFuture<T> f,
480 +                 Function<? super T,? extends CompletionStage<U>> a) {
481 +                return f.thenCompose(a);
482 +            }
483 +            public <T,U> CompletableFuture<U> handle
484 +                (CompletableFuture<T> f,
485 +                 BiFunction<? super T,Throwable,? extends U> a) {
486 +                return f.handle(a);
487 +            }
488 +            public <T> CompletableFuture<T> whenComplete
489 +                (CompletableFuture<T> f,
490 +                 BiConsumer<? super T,? super Throwable> a) {
491 +                return f.whenComplete(a);
492 +            }
493              public <T,U> CompletableFuture<Void> runAfterBoth
494                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
495                  return f.runAfterBoth(g, a);
# Line 471 | Line 506 | public class CompletableFutureTest exten
506                   BiFunction<? super T,? super U,? extends V> a) {
507                  return f.thenCombine(g, a);
508              }
509 <            public <T,U> CompletableFuture<U> applyToEither
509 >            public <T> CompletableFuture<Void> runAfterEither
510                  (CompletableFuture<T> f,
511 <                 CompletionStage<? extends T> g,
512 <                 Function<? super T,U> a) {
513 <                return f.applyToEither(g, a);
511 >                 CompletionStage<?> g,
512 >                 java.lang.Runnable a) {
513 >                return f.runAfterEither(g, a);
514              }
515              public <T> CompletableFuture<Void> acceptEither
516                  (CompletableFuture<T> f,
# Line 483 | Line 518 | public class CompletableFutureTest exten
518                   Consumer<? super T> a) {
519                  return f.acceptEither(g, a);
520              }
521 <            public <T> CompletableFuture<Void> runAfterEither
521 >            public <T,U> CompletableFuture<U> applyToEither
522                  (CompletableFuture<T> f,
523 <                 CompletionStage<?> g,
524 <                 java.lang.Runnable a) {
525 <                return f.runAfterEither(g, a);
523 >                 CompletionStage<? extends T> g,
524 >                 Function<? super T,U> a) {
525 >                return f.applyToEither(g, a);
526 >            }
527 >        },
528 >
529 >        ASYNC {
530 >            public void checkExecutionMode() {
531 >                assertSame(ForkJoinPool.commonPool(),
532 >                           ForkJoinTask.getPool());
533 >            }
534 >            public <T> CompletableFuture<Void> thenRun
535 >                (CompletableFuture<T> f, Runnable a) {
536 >                return f.thenRunAsync(a);
537 >            }
538 >            public <T> CompletableFuture<Void> thenAccept
539 >                (CompletableFuture<T> f, Consumer<? super T> a) {
540 >                return f.thenAcceptAsync(a);
541 >            }
542 >            public <T,U> CompletableFuture<U> thenApply
543 >                (CompletableFuture<T> f, Function<? super T,U> a) {
544 >                return f.thenApplyAsync(a);
545              }
546              public <T,U> CompletableFuture<U> thenCompose
547                  (CompletableFuture<T> f,
548                   Function<? super T,? extends CompletionStage<U>> a) {
549 <                return f.thenCompose(a);
549 >                return f.thenComposeAsync(a);
550 >            }
551 >            public <T,U> CompletableFuture<U> handle
552 >                (CompletableFuture<T> f,
553 >                 BiFunction<? super T,Throwable,? extends U> a) {
554 >                return f.handleAsync(a);
555              }
556              public <T> CompletableFuture<T> whenComplete
557                  (CompletableFuture<T> f,
558                   BiConsumer<? super T,? super Throwable> a) {
559 <                return f.whenComplete(a);
559 >                return f.whenCompleteAsync(a);
560              }
502 –        },
503 –
504 – //             /** Experimental way to do more testing */
505 – //         REVERSE_DEFAULT {
506 – //             public <T,U> CompletableFuture<Void> runAfterBoth
507 – //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
508 – //                 return g.runAfterBoth(f, a);
509 – //             }
510 – //             public <T,U> CompletableFuture<Void> thenAcceptBoth
511 – //                 (CompletableFuture<T> f,
512 – //                  CompletionStage<? extends U> g,
513 – //                  BiConsumer<? super T,? super U> a) {
514 – //                 return DEFAULT.thenAcceptBoth(f, g, a);
515 – //             }
516 – //         },
517 –
518 –        DEFAULT_ASYNC {
561              public <T,U> CompletableFuture<Void> runAfterBoth
562                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
563                  return f.runAfterBothAsync(g, a);
# Line 532 | Line 574 | public class CompletableFutureTest exten
574                   BiFunction<? super T,? super U,? extends V> a) {
575                  return f.thenCombineAsync(g, a);
576              }
577 <            public <T,U> CompletableFuture<U> applyToEither
577 >            public <T> CompletableFuture<Void> runAfterEither
578                  (CompletableFuture<T> f,
579 <                 CompletionStage<? extends T> g,
580 <                 Function<? super T,U> a) {
581 <                return f.applyToEitherAsync(g, a);
579 >                 CompletionStage<?> g,
580 >                 java.lang.Runnable a) {
581 >                return f.runAfterEitherAsync(g, a);
582              }
583              public <T> CompletableFuture<Void> acceptEither
584                  (CompletableFuture<T> f,
# Line 544 | Line 586 | public class CompletableFutureTest exten
586                   Consumer<? super T> a) {
587                  return f.acceptEitherAsync(g, a);
588              }
589 <            public <T> CompletableFuture<Void> runAfterEither
589 >            public <T,U> CompletableFuture<U> applyToEither
590                  (CompletableFuture<T> f,
591 <                 CompletionStage<?> g,
592 <                 java.lang.Runnable a) {
593 <                return f.runAfterEitherAsync(g, a);
591 >                 CompletionStage<? extends T> g,
592 >                 Function<? super T,U> a) {
593 >                return f.applyToEitherAsync(g, a);
594 >            }
595 >        },
596 >
597 >        EXECUTOR {
598 >            public void checkExecutionMode() {
599 >                //TODO
600 >            }
601 >            public <T> CompletableFuture<Void> thenRun
602 >                (CompletableFuture<T> f, Runnable a) {
603 >                return f.thenRunAsync(a, new ThreadExecutor());
604 >            }
605 >            public <T> CompletableFuture<Void> thenAccept
606 >                (CompletableFuture<T> f, Consumer<? super T> a) {
607 >                return f.thenAcceptAsync(a, new ThreadExecutor());
608 >            }
609 >            public <T,U> CompletableFuture<U> thenApply
610 >                (CompletableFuture<T> f, Function<? super T,U> a) {
611 >                return f.thenApplyAsync(a, new ThreadExecutor());
612              }
613              public <T,U> CompletableFuture<U> thenCompose
614                  (CompletableFuture<T> f,
615                   Function<? super T,? extends CompletionStage<U>> a) {
616 <                return f.thenComposeAsync(a);
616 >                return f.thenComposeAsync(a, new ThreadExecutor());
617 >            }
618 >            public <T,U> CompletableFuture<U> handle
619 >                (CompletableFuture<T> f,
620 >                 BiFunction<? super T,Throwable,? extends U> a) {
621 >                return f.handleAsync(a, new ThreadExecutor());
622              }
623              public <T> CompletableFuture<T> whenComplete
624                  (CompletableFuture<T> f,
625                   BiConsumer<? super T,? super Throwable> a) {
626 <                return f.whenCompleteAsync(a);
626 >                return f.whenCompleteAsync(a, new ThreadExecutor());
627              }
563 –        },
564 –
565 – //         REVERSE_DEFAULT_ASYNC {
566 – //             public <T,U> CompletableFuture<Void> runAfterBoth
567 – //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
568 – //                 return f.runAfterBothAsync(g, a);
569 – //             }
570 – //             public <T,U> CompletableFuture<Void> thenAcceptBoth
571 – //                 (CompletableFuture<T> f,
572 – //                  CompletionStage<? extends U> g,
573 – //                  BiConsumer<? super T,? super U> a) {
574 – //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
575 – //             }
576 – //         },
577 –
578 –        EXECUTOR {
628              public <T,U> CompletableFuture<Void> runAfterBoth
629                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
630                  return f.runAfterBothAsync(g, a, new ThreadExecutor());
# Line 592 | Line 641 | public class CompletableFutureTest exten
641                   BiFunction<? super T,? super U,? extends V> a) {
642                  return f.thenCombineAsync(g, a, new ThreadExecutor());
643              }
595 –            public <T,U> CompletableFuture<U> applyToEither
596 –                (CompletableFuture<T> f,
597 –                 CompletionStage<? extends T> g,
598 –                 Function<? super T,U> a) {
599 –                return f.applyToEitherAsync(g, a, new ThreadExecutor());
600 –            }
601 –            public <T> CompletableFuture<Void> acceptEither
602 –                (CompletableFuture<T> f,
603 –                 CompletionStage<? extends T> g,
604 –                 Consumer<? super T> a) {
605 –                return f.acceptEitherAsync(g, a, new ThreadExecutor());
606 –            }
644              public <T> CompletableFuture<Void> runAfterEither
645                  (CompletableFuture<T> f,
646                   CompletionStage<?> g,
647                   java.lang.Runnable a) {
648                  return f.runAfterEitherAsync(g, a, new ThreadExecutor());
649              }
650 <            public <T,U> CompletableFuture<U> thenCompose
650 >            public <T> CompletableFuture<Void> acceptEither
651                  (CompletableFuture<T> f,
652 <                 Function<? super T,? extends CompletionStage<U>> a) {
653 <                return f.thenComposeAsync(a, new ThreadExecutor());
652 >                 CompletionStage<? extends T> g,
653 >                 Consumer<? super T> a) {
654 >                return f.acceptEitherAsync(g, a, new ThreadExecutor());
655              }
656 <            public <T> CompletableFuture<T> whenComplete
656 >            public <T,U> CompletableFuture<U> applyToEither
657                  (CompletableFuture<T> f,
658 <                 BiConsumer<? super T,? super Throwable> a) {
659 <                return f.whenCompleteAsync(a, new ThreadExecutor());
658 >                 CompletionStage<? extends T> g,
659 >                 Function<? super T,U> a) {
660 >                return f.applyToEitherAsync(g, a, new ThreadExecutor());
661              }
662          };
663  
664 +        public abstract void checkExecutionMode();
665 +        public abstract <T> CompletableFuture<Void> thenRun
666 +            (CompletableFuture<T> f, Runnable a);
667 +        public abstract <T> CompletableFuture<Void> thenAccept
668 +            (CompletableFuture<T> f, Consumer<? super T> a);
669 +        public abstract <T,U> CompletableFuture<U> thenApply
670 +            (CompletableFuture<T> f, Function<? super T,U> a);
671 +        public abstract <T,U> CompletableFuture<U> thenCompose
672 +            (CompletableFuture<T> f,
673 +             Function<? super T,? extends CompletionStage<U>> a);
674 +        public abstract <T,U> CompletableFuture<U> handle
675 +            (CompletableFuture<T> f,
676 +             BiFunction<? super T,Throwable,? extends U> a);
677 +        public abstract <T> CompletableFuture<T> whenComplete
678 +            (CompletableFuture<T> f,
679 +             BiConsumer<? super T,? super Throwable> a);
680          public abstract <T,U> CompletableFuture<Void> runAfterBoth
681              (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
682          public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
# Line 632 | Line 687 | public class CompletableFutureTest exten
687              (CompletableFuture<T> f,
688               CompletionStage<? extends U> g,
689               BiFunction<? super T,? super U,? extends V> a);
635 –        public abstract <T,U> CompletableFuture<U> applyToEither
636 –            (CompletableFuture<T> f,
637 –             CompletionStage<? extends T> g,
638 –             Function<? super T,U> a);
639 –        public abstract <T> CompletableFuture<Void> acceptEither
640 –            (CompletableFuture<T> f,
641 –             CompletionStage<? extends T> g,
642 –             Consumer<? super T> a);
690          public abstract <T> CompletableFuture<Void> runAfterEither
691              (CompletableFuture<T> f,
692               CompletionStage<?> g,
693               java.lang.Runnable a);
694 <        public abstract <T,U> CompletableFuture<U> thenCompose
694 >        public abstract <T> CompletableFuture<Void> acceptEither
695              (CompletableFuture<T> f,
696 <             Function<? super T,? extends CompletionStage<U>> a);
697 <        public abstract <T> CompletableFuture<T> whenComplete
696 >             CompletionStage<? extends T> g,
697 >             Consumer<? super T> a);
698 >        public abstract <T,U> CompletableFuture<U> applyToEither
699              (CompletableFuture<T> f,
700 <             BiConsumer<? super T,? super Throwable> a);
700 >             CompletionStage<? extends T> g,
701 >             Function<? super T,U> a);
702 >    }
703  
704 +    /**
705 +     * exceptionally action is not invoked when source completes
706 +     * normally, and source result is propagated
707 +     */
708 +    public void testExceptionally_normalCompletion() {
709 +        for (boolean createIncomplete : new boolean[] { true, false })
710 +        for (Integer v1 : new Integer[] { 1, null })
711 +    {
712 +        final AtomicInteger a = new AtomicInteger(0);
713 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
714 +        if (!createIncomplete) f.complete(v1);
715 +        final CompletableFuture<Integer> g = f.exceptionally
716 +            ((Throwable t) -> {
717 +                // Should not be called
718 +                a.getAndIncrement();
719 +                throw new AssertionError();
720 +            });
721 +        if (createIncomplete) f.complete(v1);
722 +
723 +        checkCompletedNormally(g, v1);
724 +        checkCompletedNormally(f, v1);
725 +        assertEquals(0, a.get());
726 +    }}
727  
655 –    }
728  
729      /**
730       * exceptionally action completes with function value on source
731 <     * exception; otherwise with source value
731 >     * exception
732       */
733 <    public void testExceptionally() {
734 <        CompletableFuture<Integer> f = new CompletableFuture<>();
735 <        ExceptionToInteger r = new ExceptionToInteger();
736 <        CompletableFuture<Integer> g = f.exceptionally(r);
737 <        f.completeExceptionally(new CFException());
738 <        checkCompletedNormally(g, three);
733 >    public void testExceptionally_exceptionalCompletion() {
734 >        for (boolean createIncomplete : new boolean[] { true, false })
735 >        for (Integer v1 : new Integer[] { 1, null })
736 >    {
737 >        final AtomicInteger a = new AtomicInteger(0);
738 >        final CFException ex = new CFException();
739 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
740 >        if (!createIncomplete) f.completeExceptionally(ex);
741 >        final CompletableFuture<Integer> g = f.exceptionally
742 >            ((Throwable t) -> {
743 >                threadAssertSame(t, ex);
744 >                a.getAndIncrement();
745 >                return v1;
746 >            });
747 >        if (createIncomplete) f.completeExceptionally(ex);
748  
749 <        f = new CompletableFuture<>();
750 <        r = new ExceptionToInteger();
751 <        g = f.exceptionally(r);
752 <        f.complete(one);
753 <        checkCompletedNormally(g, one);
754 <    }
749 >        checkCompletedNormally(g, v1);
750 >        assertEquals(1, a.get());
751 >    }}
752 >
753 >    public void testExceptionally_exceptionalCompletionActionFailed() {
754 >        for (boolean createIncomplete : new boolean[] { true, false })
755 >        for (Integer v1 : new Integer[] { 1, null })
756 >    {
757 >        final AtomicInteger a = new AtomicInteger(0);
758 >        final CFException ex1 = new CFException();
759 >        final CFException ex2 = new CFException();
760 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
761 >        if (!createIncomplete) f.completeExceptionally(ex1);
762 >        final CompletableFuture<Integer> g = f.exceptionally
763 >            ((Throwable t) -> {
764 >                threadAssertSame(t, ex1);
765 >                a.getAndIncrement();
766 >                throw ex2;
767 >            });
768 >        if (createIncomplete) f.completeExceptionally(ex1);
769 >
770 >        checkCompletedWithWrappedCFException(g, ex2);
771 >        assertEquals(1, a.get());
772 >    }}
773  
774      /**
775 <     * handle action completes normally with function value on either
776 <     * normal or exceptional completion of source
775 >     * handle action completes normally with function value on normal
776 >     * completion of source
777       */
778 <    public void testHandle() {
779 <        CompletableFuture<Integer> f, g;
780 <        IntegerHandler r;
778 >    public void testHandle_normalCompletion() {
779 >        for (ExecutionMode m : ExecutionMode.values())
780 >        for (boolean createIncomplete : new boolean[] { true, false })
781 >        for (Integer v1 : new Integer[] { 1, null })
782 >    {
783 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
784 >        final AtomicInteger a = new AtomicInteger(0);
785 >        if (!createIncomplete) f.complete(v1);
786 >        final CompletableFuture<Integer> g = m.handle
787 >            (f,
788 >             (Integer x, Throwable t) -> {
789 >                threadAssertSame(x, v1);
790 >                threadAssertNull(t);
791 >                a.getAndIncrement();
792 >                return inc(v1);
793 >            });
794 >        if (createIncomplete) f.complete(v1);
795  
796 <        f = new CompletableFuture<>();
797 <        f.completeExceptionally(new CFException());
798 <        g = f.handle(r = new IntegerHandler());
799 <        assertTrue(r.ran);
687 <        checkCompletedNormally(g, three);
796 >        checkCompletedNormally(g, inc(v1));
797 >        checkCompletedNormally(f, v1);
798 >        assertEquals(1, a.get());
799 >    }}
800  
801 <        f = new CompletableFuture<>();
802 <        g = f.handle(r = new IntegerHandler());
803 <        assertFalse(r.ran);
804 <        f.completeExceptionally(new CFException());
805 <        checkCompletedNormally(g, three);
806 <        assertTrue(r.ran);
801 >    /**
802 >     * handle action completes normally with function value on
803 >     * exceptional completion of source
804 >     */
805 >    public void testHandle_exceptionalCompletion() {
806 >        for (ExecutionMode m : ExecutionMode.values())
807 >        for (boolean createIncomplete : new boolean[] { true, false })
808 >        for (Integer v1 : new Integer[] { 1, null })
809 >    {
810 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
811 >        final AtomicInteger a = new AtomicInteger(0);
812 >        final CFException ex = new CFException();
813 >        if (!createIncomplete) f.completeExceptionally(ex);
814 >        final CompletableFuture<Integer> g = m.handle
815 >            (f,
816 >             (Integer x, Throwable t) -> {
817 >                threadAssertNull(x);
818 >                threadAssertSame(t, ex);
819 >                a.getAndIncrement();
820 >                return v1;
821 >            });
822 >        if (createIncomplete) f.completeExceptionally(ex);
823  
824 <        f = new CompletableFuture<>();
825 <        f.complete(one);
826 <        g = f.handle(r = new IntegerHandler());
827 <        assertTrue(r.ran);
700 <        checkCompletedNormally(g, two);
824 >        checkCompletedNormally(g, v1);
825 >        checkCompletedWithWrappedCFException(f, ex);
826 >        assertEquals(1, a.get());
827 >    }}
828  
829 <        f = new CompletableFuture<>();
830 <        g = f.handle(r = new IntegerHandler());
831 <        assertFalse(r.ran);
832 <        f.complete(one);
833 <        assertTrue(r.ran);
834 <        checkCompletedNormally(g, two);
835 <    }
829 >    /**
830 >     * handle action completes normally with function value on
831 >     * cancelled source
832 >     */
833 >    public void testHandle_sourceCancelled() {
834 >        for (ExecutionMode m : ExecutionMode.values())
835 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
836 >        for (boolean createIncomplete : new boolean[] { true, false })
837 >        for (Integer v1 : new Integer[] { 1, null })
838 >    {
839 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
840 >        final AtomicInteger a = new AtomicInteger(0);
841 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
842 >        final CompletableFuture<Integer> g = m.handle
843 >            (f,
844 >             (Integer x, Throwable t) -> {
845 >                threadAssertNull(x);
846 >                threadAssertTrue(t instanceof CancellationException);
847 >                a.getAndIncrement();
848 >                return v1;
849 >            });
850 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
851 >
852 >        checkCompletedNormally(g, v1);
853 >        checkCancelled(f);
854 >        assertEquals(1, a.get());
855 >    }}
856 >
857 >    /**
858 >     * handle result completes exceptionally if action does
859 >     */
860 >    public void testHandle_sourceFailedActionFailed() {
861 >        for (ExecutionMode m : ExecutionMode.values())
862 >        for (boolean createIncomplete : new boolean[] { true, false })
863 >    {
864 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
865 >        final AtomicInteger a = new AtomicInteger(0);
866 >        final CFException ex1 = new CFException();
867 >        final CFException ex2 = new CFException();
868 >        if (!createIncomplete) f.completeExceptionally(ex1);
869 >        final CompletableFuture<Integer> g = m.handle
870 >            (f,
871 >             (Integer x, Throwable t) -> {
872 >                threadAssertNull(x);
873 >                threadAssertSame(ex1, t);
874 >                a.getAndIncrement();
875 >                throw ex2;
876 >            });
877 >        if (createIncomplete) f.completeExceptionally(ex1);
878 >
879 >        checkCompletedWithWrappedCFException(g, ex2);
880 >        checkCompletedWithWrappedCFException(f, ex1);
881 >        assertEquals(1, a.get());
882 >    }}
883 >
884 >    public void testHandle_sourceCompletedNormallyActionFailed() {
885 >        for (ExecutionMode m : ExecutionMode.values())
886 >        for (boolean createIncomplete : new boolean[] { true, false })
887 >        for (Integer v1 : new Integer[] { 1, null })
888 >    {
889 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
890 >        final AtomicInteger a = new AtomicInteger(0);
891 >        final CFException ex = new CFException();
892 >        if (!createIncomplete) f.complete(v1);
893 >        final CompletableFuture<Integer> g = m.handle
894 >            (f,
895 >             (Integer x, Throwable t) -> {
896 >                threadAssertSame(x, v1);
897 >                threadAssertNull(t);
898 >                a.getAndIncrement();
899 >                throw ex;
900 >            });
901 >        if (createIncomplete) f.complete(v1);
902 >
903 >        checkCompletedWithWrappedCFException(g, ex);
904 >        checkCompletedNormally(f, v1);
905 >        assertEquals(1, a.get());
906 >    }}
907  
908      /**
909       * runAsync completes after running Runnable
# Line 714 | Line 912 | public class CompletableFutureTest exten
912          Noop r = new Noop();
913          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
914          assertNull(f.join());
915 <        assertTrue(r.ran);
915 >        assertEquals(1, r.invocationCount);
916          checkCompletedNormally(f, null);
917      }
918  
# Line 726 | Line 924 | public class CompletableFutureTest exten
924          ThreadExecutor exec = new ThreadExecutor();
925          CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
926          assertNull(f.join());
927 <        assertTrue(r.ran);
927 >        assertEquals(1, r.invocationCount);
928          checkCompletedNormally(f, null);
929          assertEquals(1, exec.count.get());
930      }
# Line 735 | Line 933 | public class CompletableFutureTest exten
933       * failing runAsync completes exceptionally after running Runnable
934       */
935      public void testRunAsync3() {
936 <        FailingNoop r = new FailingNoop();
936 >        FailingRunnable r = new FailingRunnable();
937          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
938          checkCompletedWithWrappedCFException(f);
939 <        assertTrue(r.ran);
939 >        assertEquals(1, r.invocationCount);
940      }
941  
942      /**
# Line 768 | Line 966 | public class CompletableFutureTest exten
966          FailingSupplier r = new FailingSupplier();
967          CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
968          checkCompletedWithWrappedCFException(f);
969 <        assertTrue(r.ran);
969 >        assertEquals(1, r.invocationCount);
970      }
971  
972      // seq completion methods
# Line 776 | Line 974 | public class CompletableFutureTest exten
974      /**
975       * thenRun result completes normally after normal completion of source
976       */
977 <    public void testThenRun() {
978 <        CompletableFuture<Integer> f;
979 <        CompletableFuture<Void> g;
980 <        Noop r;
981 <
982 <        f = new CompletableFuture<>();
983 <        g = f.thenRun(r = new Noop());
984 <        f.complete(null);
985 <        checkCompletedNormally(g, null);
986 <        assertTrue(r.ran);
977 >    public void testThenRun_normalCompletion() {
978 >        for (ExecutionMode m : ExecutionMode.values())
979 >        for (boolean createIncomplete : new boolean[] { true, false })
980 >        for (Integer v1 : new Integer[] { 1, null })
981 >    {
982 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
983 >        final Noop r = new Noop();
984 >        if (!createIncomplete) f.complete(v1);
985 >        final CompletableFuture<Void> g = m.thenRun(f, r);
986 >        if (createIncomplete) {
987 >            checkIncomplete(g);
988 >            f.complete(v1);
989 >        }
990  
790 –        f = new CompletableFuture<>();
791 –        f.complete(null);
792 –        g = f.thenRun(r = new Noop());
991          checkCompletedNormally(g, null);
992 <        assertTrue(r.ran);
993 <    }
992 >        checkCompletedNormally(f, v1);
993 >        assertEquals(1, r.invocationCount);
994 >    }}
995  
996      /**
997       * thenRun result completes exceptionally after exceptional
998       * completion of source
999       */
1000 <    public void testThenRun2() {
1001 <        CompletableFuture<Integer> f;
1002 <        CompletableFuture<Void> g;
1003 <        Noop r;
1004 <
1005 <        f = new CompletableFuture<>();
1006 <        g = f.thenRun(r = new Noop());
1007 <        f.completeExceptionally(new CFException());
1008 <        checkCompletedWithWrappedCFException(g);
1009 <        assertFalse(r.ran);
1000 >    public void testThenRun_exceptionalCompletion() {
1001 >        for (ExecutionMode m : ExecutionMode.values())
1002 >        for (boolean createIncomplete : new boolean[] { true, false })
1003 >    {
1004 >        final CFException ex = new CFException();
1005 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1006 >        final Noop r = new Noop();
1007 >        if (!createIncomplete) f.completeExceptionally(ex);
1008 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1009 >        if (createIncomplete) {
1010 >            checkIncomplete(g);
1011 >            f.completeExceptionally(ex);
1012 >        }
1013  
1014 <        f = new CompletableFuture<>();
1015 <        f.completeExceptionally(new CFException());
1016 <        g = f.thenRun(r = new Noop());
1017 <        checkCompletedWithWrappedCFException(g);
816 <        assertFalse(r.ran);
817 <    }
1014 >        checkCompletedWithWrappedCFException(g, ex);
1015 >        checkCompletedWithWrappedCFException(f, ex);
1016 >        assertEquals(0, r.invocationCount);
1017 >    }}
1018  
1019      /**
1020 <     * thenRun result completes exceptionally if action does
1020 >     * thenRun result completes exceptionally if source cancelled
1021       */
1022 <    public void testThenRun3() {
1023 <        CompletableFuture<Integer> f;
1024 <        CompletableFuture<Void> g;
1025 <        FailingNoop r;
1026 <
1027 <        f = new CompletableFuture<>();
1028 <        g = f.thenRun(r = new FailingNoop());
1029 <        f.complete(null);
1030 <        checkCompletedWithWrappedCFException(g);
1022 >    public void testThenRun_sourceCancelled() {
1023 >        for (ExecutionMode m : ExecutionMode.values())
1024 >        for (boolean createIncomplete : new boolean[] { true, false })
1025 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1026 >    {
1027 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1028 >        final Noop r = new Noop();
1029 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1030 >        final CompletableFuture<Void> g = f.thenRun(r);
1031 >        if (createIncomplete) {
1032 >            checkIncomplete(g);
1033 >            assertTrue(f.cancel(mayInterruptIfRunning));
1034 >        }
1035  
1036 <        f = new CompletableFuture<>();
1037 <        f.complete(null);
1038 <        g = f.thenRun(r = new FailingNoop());
1039 <        checkCompletedWithWrappedCFException(g);
836 <    }
1036 >        checkCompletedWithWrappedCancellationException(g);
1037 >        checkCancelled(f);
1038 >        assertEquals(0, r.invocationCount);
1039 >    }}
1040  
1041      /**
1042 <     * thenRun result completes exceptionally if source cancelled
1042 >     * thenRun result completes exceptionally if action does
1043       */
1044 <    public void testThenRun4() {
1045 <        CompletableFuture<Integer> f;
1046 <        CompletableFuture<Void> g;
1047 <        Noop r;
1048 <
1049 <        f = new CompletableFuture<>();
1050 <        g = f.thenRun(r = new Noop());
1051 <        assertTrue(f.cancel(true));
1052 <        checkCompletedWithWrappedCancellationException(g);
1044 >    public void testThenRun_actionFailed() {
1045 >        for (ExecutionMode m : ExecutionMode.values())
1046 >        for (boolean createIncomplete : new boolean[] { true, false })
1047 >        for (Integer v1 : new Integer[] { 1, null })
1048 >    {
1049 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1050 >        final FailingRunnable r = new FailingRunnable();
1051 >        if (!createIncomplete) f.complete(v1);
1052 >        final CompletableFuture<Void> g = f.thenRun(r);
1053 >        if (createIncomplete) {
1054 >            checkIncomplete(g);
1055 >            f.complete(v1);
1056 >        }
1057  
1058 <        f = new CompletableFuture<>();
1059 <        assertTrue(f.cancel(true));
1060 <        g = f.thenRun(r = new Noop());
854 <        checkCompletedWithWrappedCancellationException(g);
855 <    }
1058 >        checkCompletedWithWrappedCFException(g);
1059 >        checkCompletedNormally(f, v1);
1060 >    }}
1061  
1062      /**
1063       * thenApply result completes normally after normal completion of source
1064       */
1065 <    public void testThenApply() {
1066 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1067 <        CompletableFuture<Integer> g = f.thenApply(inc);
1068 <        f.complete(one);
1069 <        checkCompletedNormally(g, two);
1070 <    }
1065 >    public void testThenApply_normalCompletion() {
1066 >        for (ExecutionMode m : ExecutionMode.values())
1067 >        for (boolean createIncomplete : new boolean[] { true, false })
1068 >        for (Integer v1 : new Integer[] { 1, null })
1069 >    {
1070 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1071 >        final IncFunction r = new IncFunction();
1072 >        if (!createIncomplete) f.complete(v1);
1073 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1074 >        if (createIncomplete) {
1075 >            checkIncomplete(g);
1076 >            f.complete(v1);
1077 >        }
1078 >
1079 >        checkCompletedNormally(g, inc(v1));
1080 >        checkCompletedNormally(f, v1);
1081 >        assertEquals(1, r.invocationCount);
1082 >    }}
1083  
1084      /**
1085       * thenApply result completes exceptionally after exceptional
1086       * completion of source
1087       */
1088 <    public void testThenApply2() {
1089 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1090 <        CompletableFuture<Integer> g = f.thenApply(inc);
1091 <        f.completeExceptionally(new CFException());
1092 <        checkCompletedWithWrappedCFException(g);
1093 <    }
1088 >    public void testThenApply_exceptionalCompletion() {
1089 >        for (ExecutionMode m : ExecutionMode.values())
1090 >        for (boolean createIncomplete : new boolean[] { true, false })
1091 >    {
1092 >        final CFException ex = new CFException();
1093 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1094 >        final IncFunction r = new IncFunction();
1095 >        if (!createIncomplete) f.completeExceptionally(ex);
1096 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1097 >        if (createIncomplete) {
1098 >            checkIncomplete(g);
1099 >            f.completeExceptionally(ex);
1100 >        }
1101  
1102 <    /**
1103 <     * thenApply result completes exceptionally if action does
1104 <     */
1105 <    public void testThenApply3() {
882 <        CompletableFuture<Integer> f = new CompletableFuture<>();
883 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
884 <        f.complete(one);
885 <        checkCompletedWithWrappedCFException(g);
886 <    }
1102 >        checkCompletedWithWrappedCFException(g, ex);
1103 >        checkCompletedWithWrappedCFException(f, ex);
1104 >        assertEquals(0, r.invocationCount);
1105 >    }}
1106  
1107      /**
1108       * thenApply result completes exceptionally if source cancelled
1109       */
1110 <    public void testThenApply4() {
1111 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1112 <        CompletableFuture<Integer> g = f.thenApply(inc);
1113 <        assertTrue(f.cancel(true));
1110 >    public void testThenApply_sourceCancelled() {
1111 >        for (ExecutionMode m : ExecutionMode.values())
1112 >        for (boolean createIncomplete : new boolean[] { true, false })
1113 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1114 >    {
1115 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1116 >        final IncFunction r = new IncFunction();
1117 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1118 >        final CompletableFuture<Integer> g = f.thenApply(r);
1119 >        if (createIncomplete) {
1120 >            checkIncomplete(g);
1121 >            assertTrue(f.cancel(mayInterruptIfRunning));
1122 >        }
1123 >
1124          checkCompletedWithWrappedCancellationException(g);
1125 <    }
1125 >        checkCancelled(f);
1126 >        assertEquals(0, r.invocationCount);
1127 >    }}
1128  
1129      /**
1130 <     * 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  
910 –    /**
911 –     * thenAccept result completes exceptionally after exceptional
912 –     * completion of source
913 –     */
914 –    public void testThenAccept2() {
915 –        CompletableFuture<Integer> f = new CompletableFuture<>();
916 –        IncAction r = new IncAction();
917 –        CompletableFuture<Void> g = f.thenAccept(r);
918 –        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<>();
939 <        IncAction r = new IncAction();
940 <        CompletableFuture<Void> g = f.thenAccept(r);
941 <        assertTrue(f.cancel(true));
942 <        checkCompletedWithWrappedCancellationException(g);
943 <    }
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);
961 <        assertEquals(r.invocationCount, 0);
962 <        g.complete(v2);
963 <
964 <        checkCompletedNormally(h, subtract(v1, v2));
965 <        checkCompletedNormally(f, v1);
966 <        checkCompletedNormally(g, v2);
967 <        assertEquals(r.invocationCount, 1);
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          }
969 –    }
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 }) {
975 <
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 <        assertEquals(r.invocationCount, 0);
984 <        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);
989 <        assertEquals(r.invocationCount, 1);
990 <        }
991 <    }
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);
1005 <
1006 <        checkCompletedNormally(h, subtract(v1, v2));
1007 <        checkCompletedNormally(f, v1);
1008 <        checkCompletedNormally(g, v2);
1009 <        assertEquals(r.invocationCount, 1);
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          }
1011 –    }
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 <        assertEquals(r.invocationCount, 1);
1268 <        }
1031 <    }
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() {
1038 <        for (ExecutionMode m : ExecutionMode.values())
1039 <        for (Integer v1 : new Integer[] { 1, null }) {
1040 <
1041 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1042 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1043 <        final SubtractFunction r = new SubtractFunction();
1044 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1045 <        final CFException ex = new CFException();
1046 <
1047 <        f.completeExceptionally(ex);
1048 <        checkIncomplete(h);
1049 <        g.complete(v1);
1050 <
1051 <        checkCompletedWithWrappedCFException(h, ex);
1052 <        checkCompletedWithWrappedCFException(f, ex);
1053 <        assertEquals(r.invocationCount, 0);
1054 <        checkCompletedNormally(g, v1);
1055 <        }
1056 <    }
1057 <
1058 <    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<>();
1064 –        final SubtractFunction r = new SubtractFunction();
1065 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1282          final CFException ex = new CFException();
1067 –
1068 –        g.completeExceptionally(ex);
1069 –        checkIncomplete(h);
1070 –        f.complete(v1);
1071 –
1072 –        checkCompletedWithWrappedCFException(h, ex);
1073 –        checkCompletedWithWrappedCFException(g, ex);
1074 –        assertEquals(r.invocationCount, 0);
1075 –        checkCompletedNormally(f, v1);
1076 –        }
1077 –    }
1078 –
1079 –    public void testThenCombine_exceptionalCompletion3() {
1080 –        for (ExecutionMode m : ExecutionMode.values())
1081 –        for (Integer v1 : new Integer[] { 1, null }) {
1082 –
1083 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1084 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1283          final SubtractFunction r = new SubtractFunction();
1086 –        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);
1094 <        assertEquals(r.invocationCount, 0);
1095 <        checkCompletedNormally(f, v1);
1289 >        if (createIncomplete) {
1290 >            checkIncomplete(h);
1291 >            (!fFirst ? f : g).completeExceptionally(ex);
1292          }
1097 –    }
1098 –
1099 –    public void testThenCombine_exceptionalCompletion4() {
1100 –        for (ExecutionMode m : ExecutionMode.values())
1101 –        for (Integer v1 : new Integer[] { 1, null }) {
1102 –
1103 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1104 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1105 –        final SubtractFunction r = new SubtractFunction();
1106 –        final CFException ex = new CFException();
1107 –
1108 –        f.completeExceptionally(ex);
1109 –        g.complete(v1);
1110 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1293  
1294          checkCompletedWithWrappedCFException(h, ex);
1295 <        checkCompletedWithWrappedCFException(f, ex);
1296 <        assertEquals(r.invocationCount, 0);
1297 <        checkCompletedNormally(g, v1);
1298 <        }
1117 <    }
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);
1138 <        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          }
1140 –    }
1141 –
1142 –    public void testThenCombine_actionFailed2() {
1143 –        for (ExecutionMode m : ExecutionMode.values())
1144 –        for (Integer v1 : new Integer[] { 1, null })
1145 –        for (Integer v2 : new Integer[] { 2, null }) {
1146 –
1147 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1148 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1149 –        final FailingBiFunction r = new FailingBiFunction();
1150 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1151 –
1152 –        g.complete(v2);
1153 –        checkIncomplete(h);
1154 –        f.complete(v1);
1321  
1322          checkCompletedWithWrappedCFException(h);
1323          checkCompletedNormally(f, v1);
1324          checkCompletedNormally(g, v2);
1325 <        }
1160 <    }
1325 >    }}
1326  
1327      /**
1328       * thenCombine result completes exceptionally if either source cancelled
1329       */
1330 <    public void testThenCombine_sourceCancelled1() {
1166 <        for (ExecutionMode m : ExecutionMode.values())
1167 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1168 <        for (Integer v1 : new Integer[] { 1, null }) {
1169 <
1170 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1171 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1172 <        final SubtractFunction r = new SubtractFunction();
1173 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1174 <
1175 <        assertTrue(f.cancel(mayInterruptIfRunning));
1176 <        checkIncomplete(h);
1177 <        g.complete(v1);
1178 <
1179 <        checkCompletedWithWrappedCancellationException(h);
1180 <        checkCancelled(f);
1181 <        assertEquals(r.invocationCount, 0);
1182 <        checkCompletedNormally(g, v1);
1183 <        }
1184 <    }
1185 <
1186 <    public void testThenCombine_sourceCancelled2() {
1187 <        for (ExecutionMode m : ExecutionMode.values())
1188 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1189 <        for (Integer v1 : new Integer[] { 1, null }) {
1190 <
1191 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1192 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1193 <        final SubtractFunction r = new SubtractFunction();
1194 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1195 <
1196 <        assertTrue(g.cancel(mayInterruptIfRunning));
1197 <        checkIncomplete(h);
1198 <        f.complete(v1);
1199 <
1200 <        checkCompletedWithWrappedCancellationException(h);
1201 <        checkCancelled(g);
1202 <        assertEquals(r.invocationCount, 0);
1203 <        checkCompletedNormally(f, v1);
1204 <        }
1205 <    }
1206 <
1207 <    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);
1222 <        assertEquals(r.invocationCount, 0);
1223 <        checkCompletedNormally(f, v1);
1345 >        if (createIncomplete) {
1346 >            checkIncomplete(h);
1347 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1348          }
1225 –    }
1226 –
1227 –    public void testThenCombine_sourceCancelled4() {
1228 –        for (ExecutionMode m : ExecutionMode.values())
1229 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1230 –        for (Integer v1 : new Integer[] { 1, null }) {
1231 –
1232 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1233 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1234 –        final SubtractFunction r = new SubtractFunction();
1235 –
1236 –        assertTrue(f.cancel(mayInterruptIfRunning));
1237 –        g.complete(v1);
1238 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1349  
1350          checkCompletedWithWrappedCancellationException(h);
1351 <        checkCancelled(f);
1352 <        assertEquals(r.invocationCount, 0);
1353 <        checkCompletedNormally(g, v1);
1354 <        }
1245 <    }
1351 >        checkCancelled(!fFirst ? f : g);
1352 >        assertEquals(0, r.invocationCount);
1353 >        checkCompletedNormally(fFirst ? f : g, v1);
1354 >    }}
1355  
1356      /**
1357       * thenAcceptBoth result completes normally after normal
1358       * completion of sources
1359       */
1360 <    public void testThenAcceptBoth_normalCompletion1() {
1252 <        for (ExecutionMode m : ExecutionMode.values())
1253 <        for (Integer v1 : new Integer[] { 1, null })
1254 <        for (Integer v2 : new Integer[] { 2, null }) {
1255 <
1256 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1257 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1258 <        final SubtractAction r = new SubtractAction();
1259 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1260 <
1261 <        f.complete(v1);
1262 <        checkIncomplete(h);
1263 <        assertFalse(r.ran());
1264 <        g.complete(v2);
1265 <
1266 <        checkCompletedNormally(h, null);
1267 <        assertEquals(r.value, subtract(v1, v2));
1268 <        checkCompletedNormally(f, v1);
1269 <        checkCompletedNormally(g, v2);
1270 <        }
1271 <    }
1272 <
1273 <    public void testThenAcceptBoth_normalCompletion2() {
1360 >    public void testThenAcceptBoth_normalCompletion() {
1361          for (ExecutionMode m : ExecutionMode.values())
1362 +        for (boolean createIncomplete : new boolean[] { true, false })
1363 +        for (boolean fFirst : new boolean[] { true, false })
1364          for (Integer v1 : new Integer[] { 1, null })
1365 <        for (Integer v2 : new Integer[] { 2, null }) {
1366 <
1278 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1279 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1280 <        final SubtractAction r = new SubtractAction();
1281 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1282 <
1283 <        g.complete(v2);
1284 <        checkIncomplete(h);
1285 <        assertFalse(r.ran());
1286 <        f.complete(v1);
1287 <
1288 <        checkCompletedNormally(h, null);
1289 <        assertEquals(r.value, subtract(v1, v2));
1290 <        checkCompletedNormally(f, v1);
1291 <        checkCompletedNormally(g, v2);
1292 <        }
1293 <    }
1294 <
1295 <    public void testThenAcceptBoth_normalCompletion3() {
1296 <        for (ExecutionMode m : ExecutionMode.values())
1297 <        for (Integer v1 : new Integer[] { 1, null })
1298 <        for (Integer v2 : new Integer[] { 2, null }) {
1299 <
1365 >        for (Integer v2 : new Integer[] { 2, null })
1366 >    {
1367          final CompletableFuture<Integer> f = new CompletableFuture<>();
1368          final CompletableFuture<Integer> g = new CompletableFuture<>();
1369          final SubtractAction r = new SubtractAction();
1370  
1371 <        g.complete(v2);
1372 <        f.complete(v1);
1371 >        if (fFirst) f.complete(v1); else g.complete(v2);
1372 >        if (!createIncomplete)
1373 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1374          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1375 <
1376 <        checkCompletedNormally(h, null);
1377 <        assertEquals(r.value, subtract(v1, v2));
1378 <        checkCompletedNormally(f, v1);
1311 <        checkCompletedNormally(g, v2);
1375 >        if (createIncomplete) {
1376 >            checkIncomplete(h);
1377 >            assertEquals(0, r.invocationCount);
1378 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1379          }
1313 –    }
1314 –
1315 –    public void testThenAcceptBoth_normalCompletion4() {
1316 –        for (ExecutionMode m : ExecutionMode.values())
1317 –        for (Integer v1 : new Integer[] { 1, null })
1318 –        for (Integer v2 : new Integer[] { 2, null }) {
1319 –
1320 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1321 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1322 –        final SubtractAction r = new SubtractAction();
1323 –
1324 –        f.complete(v1);
1325 –        g.complete(v2);
1326 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1380  
1381          checkCompletedNormally(h, null);
1382 <        assertEquals(r.value, subtract(v1, v2));
1382 >        assertEquals(subtract(v1, v2), r.value);
1383          checkCompletedNormally(f, v1);
1384          checkCompletedNormally(g, v2);
1385 <        }
1333 <    }
1385 >    }}
1386  
1387      /**
1388       * thenAcceptBoth result completes exceptionally after exceptional
1389       * completion of either source
1390       */
1391 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1340 <        for (ExecutionMode m : ExecutionMode.values())
1341 <        for (Integer v1 : new Integer[] { 1, null }) {
1342 <
1343 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1344 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1345 <        final SubtractAction r = new SubtractAction();
1346 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1347 <        final CFException ex = new CFException();
1348 <
1349 <        f.completeExceptionally(ex);
1350 <        checkIncomplete(h);
1351 <        g.complete(v1);
1352 <
1353 <        checkCompletedWithWrappedCFException(h, ex);
1354 <        checkCompletedWithWrappedCFException(f, ex);
1355 <        assertEquals(r.invocationCount, 0);
1356 <        checkCompletedNormally(g, v1);
1357 <        }
1358 <    }
1359 <
1360 <    public void testThenAcceptBoth_exceptionalCompletion2() {
1391 >    public void testThenAcceptBoth_exceptionalCompletion() {
1392          for (ExecutionMode m : ExecutionMode.values())
1393 <        for (Integer v1 : new Integer[] { 1, null }) {
1394 <
1393 >        for (boolean createIncomplete : new boolean[] { true, false })
1394 >        for (boolean fFirst : new boolean[] { true, false })
1395 >        for (Integer v1 : new Integer[] { 1, null })
1396 >    {
1397          final CompletableFuture<Integer> f = new CompletableFuture<>();
1398          final CompletableFuture<Integer> g = new CompletableFuture<>();
1366 –        final SubtractAction r = new SubtractAction();
1367 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1399          final CFException ex = new CFException();
1369 –
1370 –        g.completeExceptionally(ex);
1371 –        checkIncomplete(h);
1372 –        f.complete(v1);
1373 –
1374 –        checkCompletedWithWrappedCFException(h, ex);
1375 –        checkCompletedWithWrappedCFException(g, ex);
1376 –        assertEquals(r.invocationCount, 0);
1377 –        checkCompletedNormally(f, v1);
1378 –        }
1379 –    }
1380 –
1381 –    public void testThenAcceptBoth_exceptionalCompletion3() {
1382 –        for (ExecutionMode m : ExecutionMode.values())
1383 –        for (Integer v1 : new Integer[] { 1, null }) {
1384 –
1385 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1386 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1400          final SubtractAction r = new SubtractAction();
1388 –        final CFException ex = new CFException();
1401  
1402 <        g.completeExceptionally(ex);
1403 <        f.complete(v1);
1402 >        (fFirst ? f : g).complete(v1);
1403 >        if (!createIncomplete)
1404 >            (!fFirst ? f : g).completeExceptionally(ex);
1405          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1406 <
1407 <        checkCompletedWithWrappedCFException(h, ex);
1408 <        checkCompletedWithWrappedCFException(g, ex);
1396 <        assertEquals(r.invocationCount, 0);
1397 <        checkCompletedNormally(f, v1);
1406 >        if (createIncomplete) {
1407 >            checkIncomplete(h);
1408 >            (!fFirst ? f : g).completeExceptionally(ex);
1409          }
1399 –    }
1400 –
1401 –    public void testThenAcceptBoth_exceptionalCompletion4() {
1402 –        for (ExecutionMode m : ExecutionMode.values())
1403 –        for (Integer v1 : new Integer[] { 1, null }) {
1404 –
1405 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1406 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1407 –        final SubtractAction r = new SubtractAction();
1408 –        final CFException ex = new CFException();
1409 –
1410 –        f.completeExceptionally(ex);
1411 –        g.complete(v1);
1412 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1410  
1411          checkCompletedWithWrappedCFException(h, ex);
1412 <        checkCompletedWithWrappedCFException(f, ex);
1413 <        assertFalse(r.ran());
1414 <        checkCompletedNormally(g, v1);
1415 <        }
1419 <    }
1412 >        assertEquals(0, r.invocationCount);
1413 >        checkCompletedNormally(fFirst ? f : g, v1);
1414 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1415 >    }}
1416  
1417      /**
1418       * thenAcceptBoth result completes exceptionally if action does
1419       */
1420 <    public void testThenAcceptBoth_actionFailed1() {
1420 >    public void testThenAcceptBoth_actionFailed() {
1421          for (ExecutionMode m : ExecutionMode.values())
1422 +        for (boolean fFirst : new boolean[] { true, false })
1423          for (Integer v1 : new Integer[] { 1, null })
1424 <        for (Integer v2 : new Integer[] { 2, null }) {
1425 <
1424 >        for (Integer v2 : new Integer[] { 2, null })
1425 >    {
1426          final CompletableFuture<Integer> f = new CompletableFuture<>();
1427          final CompletableFuture<Integer> g = new CompletableFuture<>();
1428          final FailingBiConsumer r = new FailingBiConsumer();
1429          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1430  
1431 <        f.complete(v1);
1432 <        checkIncomplete(h);
1433 <        g.complete(v2);
1434 <
1435 <        checkCompletedWithWrappedCFException(h);
1436 <        checkCompletedNormally(f, v1);
1440 <        checkCompletedNormally(g, v2);
1431 >        if (fFirst) {
1432 >            f.complete(v1);
1433 >            g.complete(v2);
1434 >        } else {
1435 >            g.complete(v2);
1436 >            f.complete(v1);
1437          }
1442 –    }
1443 –
1444 –    public void testThenAcceptBoth_actionFailed2() {
1445 –        for (ExecutionMode m : ExecutionMode.values())
1446 –        for (Integer v1 : new Integer[] { 1, null })
1447 –        for (Integer v2 : new Integer[] { 2, null }) {
1448 –
1449 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1450 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1451 –        final FailingBiConsumer r = new FailingBiConsumer();
1452 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1453 –
1454 –        g.complete(v2);
1455 –        checkIncomplete(h);
1456 –        f.complete(v1);
1438  
1439          checkCompletedWithWrappedCFException(h);
1440          checkCompletedNormally(f, v1);
1441          checkCompletedNormally(g, v2);
1442 <        }
1462 <    }
1442 >    }}
1443  
1444      /**
1445       * thenAcceptBoth result completes exceptionally if either source cancelled
1446       */
1447 <    public void testThenAcceptBoth_sourceCancelled1() {
1468 <        for (ExecutionMode m : ExecutionMode.values())
1469 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1470 <        for (Integer v1 : new Integer[] { 1, null }) {
1471 <
1472 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1473 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1474 <        final SubtractAction r = new SubtractAction();
1475 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1476 <
1477 <        assertTrue(f.cancel(mayInterruptIfRunning));
1478 <        checkIncomplete(h);
1479 <        g.complete(v1);
1480 <
1481 <        checkCompletedWithWrappedCancellationException(h);
1482 <        checkCancelled(f);
1483 <        assertEquals(r.invocationCount, 0);
1484 <        checkCompletedNormally(g, v1);
1485 <        }
1486 <    }
1487 <
1488 <    public void testThenAcceptBoth_sourceCancelled2() {
1447 >    public void testThenAcceptBoth_sourceCancelled() {
1448          for (ExecutionMode m : ExecutionMode.values())
1449          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1450 <        for (Integer v1 : new Integer[] { 1, null }) {
1451 <
1452 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1453 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1495 <        final SubtractAction r = new SubtractAction();
1496 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1497 <
1498 <        assertTrue(g.cancel(mayInterruptIfRunning));
1499 <        checkIncomplete(h);
1500 <        f.complete(v1);
1501 <
1502 <        checkCompletedWithWrappedCancellationException(h);
1503 <        checkCancelled(g);
1504 <        assertEquals(r.invocationCount, 0);
1505 <        checkCompletedNormally(f, v1);
1506 <        }
1507 <    }
1508 <
1509 <    public void testThenAcceptBoth_sourceCancelled3() {
1510 <        for (ExecutionMode m : ExecutionMode.values())
1511 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1512 <        for (Integer v1 : new Integer[] { 1, null }) {
1513 <
1450 >        for (boolean createIncomplete : new boolean[] { true, false })
1451 >        for (boolean fFirst : new boolean[] { true, false })
1452 >        for (Integer v1 : new Integer[] { 1, null })
1453 >    {
1454          final CompletableFuture<Integer> f = new CompletableFuture<>();
1455          final CompletableFuture<Integer> g = new CompletableFuture<>();
1456          final SubtractAction r = new SubtractAction();
1457  
1458 <        assertTrue(g.cancel(mayInterruptIfRunning));
1459 <        f.complete(v1);
1458 >        (fFirst ? f : g).complete(v1);
1459 >        if (!createIncomplete)
1460 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1461          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1462 <
1463 <        checkCompletedWithWrappedCancellationException(h);
1464 <        checkCancelled(g);
1524 <        assertEquals(r.invocationCount, 0);
1525 <        checkCompletedNormally(f, v1);
1462 >        if (createIncomplete) {
1463 >            checkIncomplete(h);
1464 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1465          }
1527 –    }
1528 –
1529 –    public void testThenAcceptBoth_sourceCancelled4() {
1530 –        for (ExecutionMode m : ExecutionMode.values())
1531 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1532 –        for (Integer v1 : new Integer[] { 1, null }) {
1533 –
1534 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1535 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1536 –        final SubtractAction r = new SubtractAction();
1537 –
1538 –        assertTrue(f.cancel(mayInterruptIfRunning));
1539 –        g.complete(v1);
1540 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1466  
1467          checkCompletedWithWrappedCancellationException(h);
1468 <        checkCancelled(f);
1469 <        assertEquals(r.invocationCount, 0);
1470 <        checkCompletedNormally(g, v1);
1471 <        }
1547 <    }
1468 >        checkCancelled(!fFirst ? f : g);
1469 >        assertEquals(0, r.invocationCount);
1470 >        checkCompletedNormally(fFirst ? f : g, v1);
1471 >    }}
1472  
1473      /**
1474       * runAfterBoth result completes normally after normal
# Line 1553 | Line 1477 | public class CompletableFutureTest exten
1477      public void testRunAfterBoth_normalCompletion1() {
1478          for (ExecutionMode m : ExecutionMode.values())
1479          for (Integer v1 : new Integer[] { 1, null })
1480 <        for (Integer v2 : new Integer[] { 2, null }) {
1481 <
1480 >        for (Integer v2 : new Integer[] { 2, null })
1481 >    {
1482          final CompletableFuture<Integer> f = new CompletableFuture<>();
1483          final CompletableFuture<Integer> g = new CompletableFuture<>();
1484          final Noop r = new Noop();
# Line 1562 | Line 1486 | public class CompletableFutureTest exten
1486  
1487          f.complete(v1);
1488          checkIncomplete(h);
1489 <        assertFalse(r.ran);
1489 >        assertEquals(0, r.invocationCount);
1490          g.complete(v2);
1491  
1492          checkCompletedNormally(h, null);
1493 <        assertEquals(r.invocationCount, 1);
1493 >        assertEquals(1, r.invocationCount);
1494          checkCompletedNormally(f, v1);
1495          checkCompletedNormally(g, v2);
1496 <        }
1573 <    }
1496 >    }}
1497  
1498      public void testRunAfterBoth_normalCompletion2() {
1499          for (ExecutionMode m : ExecutionMode.values())
1500          for (Integer v1 : new Integer[] { 1, null })
1501 <        for (Integer v2 : new Integer[] { 2, null }) {
1502 <
1501 >        for (Integer v2 : new Integer[] { 2, null })
1502 >    {
1503          final CompletableFuture<Integer> f = new CompletableFuture<>();
1504          final CompletableFuture<Integer> g = new CompletableFuture<>();
1505          final Noop r = new Noop();
# Line 1584 | Line 1507 | public class CompletableFutureTest exten
1507  
1508          g.complete(v2);
1509          checkIncomplete(h);
1510 <        assertFalse(r.ran);
1510 >        assertEquals(0, r.invocationCount);
1511          f.complete(v1);
1512  
1513          checkCompletedNormally(h, null);
1514 <        assertEquals(r.invocationCount, 1);
1514 >        assertEquals(1, r.invocationCount);
1515          checkCompletedNormally(f, v1);
1516          checkCompletedNormally(g, v2);
1517 <        }
1595 <    }
1517 >    }}
1518  
1519      public void testRunAfterBoth_normalCompletion3() {
1520          for (ExecutionMode m : ExecutionMode.values())
1521          for (Integer v1 : new Integer[] { 1, null })
1522 <        for (Integer v2 : new Integer[] { 2, null }) {
1523 <
1522 >        for (Integer v2 : new Integer[] { 2, null })
1523 >    {
1524          final CompletableFuture<Integer> f = new CompletableFuture<>();
1525          final CompletableFuture<Integer> g = new CompletableFuture<>();
1526          final Noop r = new Noop();
# Line 1608 | Line 1530 | public class CompletableFutureTest exten
1530          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1531  
1532          checkCompletedNormally(h, null);
1533 <        assertTrue(r.ran);
1533 >        assertEquals(1, r.invocationCount);
1534          checkCompletedNormally(f, v1);
1535          checkCompletedNormally(g, v2);
1536 <        }
1615 <    }
1536 >    }}
1537  
1538      public void testRunAfterBoth_normalCompletion4() {
1539          for (ExecutionMode m : ExecutionMode.values())
1540          for (Integer v1 : new Integer[] { 1, null })
1541 <        for (Integer v2 : new Integer[] { 2, null }) {
1542 <
1541 >        for (Integer v2 : new Integer[] { 2, null })
1542 >    {
1543          final CompletableFuture<Integer> f = new CompletableFuture<>();
1544          final CompletableFuture<Integer> g = new CompletableFuture<>();
1545          final Noop r = new Noop();
# Line 1628 | Line 1549 | public class CompletableFutureTest exten
1549          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1550  
1551          checkCompletedNormally(h, null);
1552 <        assertEquals(r.invocationCount, 1);
1552 >        assertEquals(1, r.invocationCount);
1553          checkCompletedNormally(f, v1);
1554          checkCompletedNormally(g, v2);
1555 <        }
1635 <    }
1555 >    }}
1556  
1557      /**
1558       * runAfterBoth result completes exceptionally after exceptional
# Line 1640 | Line 1560 | public class CompletableFutureTest exten
1560       */
1561      public void testRunAfterBoth_exceptionalCompletion1() {
1562          for (ExecutionMode m : ExecutionMode.values())
1563 <        for (Integer v1 : new Integer[] { 1, null }) {
1564 <
1563 >        for (Integer v1 : new Integer[] { 1, null })
1564 >    {
1565          final CompletableFuture<Integer> f = new CompletableFuture<>();
1566          final CompletableFuture<Integer> g = new CompletableFuture<>();
1567          final Noop r = new Noop();
# Line 1654 | Line 1574 | public class CompletableFutureTest exten
1574  
1575          checkCompletedWithWrappedCFException(h, ex);
1576          checkCompletedWithWrappedCFException(f, ex);
1577 <        assertEquals(r.invocationCount, 0);
1577 >        assertEquals(0, r.invocationCount);
1578          checkCompletedNormally(g, v1);
1579 <        }
1660 <    }
1579 >    }}
1580  
1581      public void testRunAfterBoth_exceptionalCompletion2() {
1582          for (ExecutionMode m : ExecutionMode.values())
1583 <        for (Integer v1 : new Integer[] { 1, null }) {
1584 <
1583 >        for (Integer v1 : new Integer[] { 1, null })
1584 >    {
1585          final CompletableFuture<Integer> f = new CompletableFuture<>();
1586          final CompletableFuture<Integer> g = new CompletableFuture<>();
1587          final Noop r = new Noop();
# Line 1675 | Line 1594 | public class CompletableFutureTest exten
1594  
1595          checkCompletedWithWrappedCFException(h, ex);
1596          checkCompletedWithWrappedCFException(g, ex);
1597 <        assertEquals(r.invocationCount, 0);
1597 >        assertEquals(0, r.invocationCount);
1598          checkCompletedNormally(f, v1);
1599 <        }
1681 <    }
1599 >    }}
1600  
1601      public void testRunAfterBoth_exceptionalCompletion3() {
1602          for (ExecutionMode m : ExecutionMode.values())
1603 <        for (Integer v1 : new Integer[] { 1, null }) {
1604 <
1603 >        for (Integer v1 : new Integer[] { 1, null })
1604 >    {
1605          final CompletableFuture<Integer> f = new CompletableFuture<>();
1606          final CompletableFuture<Integer> g = new CompletableFuture<>();
1607          final Noop r = new Noop();
# Line 1695 | Line 1613 | public class CompletableFutureTest exten
1613  
1614          checkCompletedWithWrappedCFException(h, ex);
1615          checkCompletedWithWrappedCFException(g, ex);
1616 <        assertEquals(r.invocationCount, 0);
1616 >        assertEquals(0, r.invocationCount);
1617          checkCompletedNormally(f, v1);
1618 <        }
1701 <    }
1618 >    }}
1619  
1620      public void testRunAfterBoth_exceptionalCompletion4() {
1621          for (ExecutionMode m : ExecutionMode.values())
1622 <        for (Integer v1 : new Integer[] { 1, null }) {
1623 <
1622 >        for (Integer v1 : new Integer[] { 1, null })
1623 >    {
1624          final CompletableFuture<Integer> f = new CompletableFuture<>();
1625          final CompletableFuture<Integer> g = new CompletableFuture<>();
1626          final Noop r = new Noop();
# Line 1715 | Line 1632 | public class CompletableFutureTest exten
1632  
1633          checkCompletedWithWrappedCFException(h, ex);
1634          checkCompletedWithWrappedCFException(f, ex);
1635 <        assertEquals(r.invocationCount, 0);
1635 >        assertEquals(0, r.invocationCount);
1636          checkCompletedNormally(g, v1);
1637 <        }
1721 <    }
1637 >    }}
1638  
1639      /**
1640       * runAfterBoth result completes exceptionally if action does
# Line 1726 | Line 1642 | public class CompletableFutureTest exten
1642      public void testRunAfterBoth_actionFailed1() {
1643          for (ExecutionMode m : ExecutionMode.values())
1644          for (Integer v1 : new Integer[] { 1, null })
1645 <        for (Integer v2 : new Integer[] { 2, null }) {
1646 <
1645 >        for (Integer v2 : new Integer[] { 2, null })
1646 >    {
1647          final CompletableFuture<Integer> f = new CompletableFuture<>();
1648          final CompletableFuture<Integer> g = new CompletableFuture<>();
1649 <        final FailingNoop r = new FailingNoop();
1649 >        final FailingRunnable r = new FailingRunnable();
1650          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1651  
1652          f.complete(v1);
# Line 1740 | Line 1656 | public class CompletableFutureTest exten
1656          checkCompletedWithWrappedCFException(h);
1657          checkCompletedNormally(f, v1);
1658          checkCompletedNormally(g, v2);
1659 <        }
1744 <    }
1659 >    }}
1660  
1661      public void testRunAfterBoth_actionFailed2() {
1662          for (ExecutionMode m : ExecutionMode.values())
1663          for (Integer v1 : new Integer[] { 1, null })
1664 <        for (Integer v2 : new Integer[] { 2, null }) {
1665 <
1664 >        for (Integer v2 : new Integer[] { 2, null })
1665 >    {
1666          final CompletableFuture<Integer> f = new CompletableFuture<>();
1667          final CompletableFuture<Integer> g = new CompletableFuture<>();
1668 <        final FailingNoop r = new FailingNoop();
1668 >        final FailingRunnable r = new FailingRunnable();
1669          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1670  
1671          g.complete(v2);
# Line 1760 | Line 1675 | public class CompletableFutureTest exten
1675          checkCompletedWithWrappedCFException(h);
1676          checkCompletedNormally(f, v1);
1677          checkCompletedNormally(g, v2);
1678 <        }
1764 <    }
1678 >    }}
1679  
1680      /**
1681       * runAfterBoth result completes exceptionally if either source cancelled
# Line 1769 | Line 1683 | public class CompletableFutureTest exten
1683      public void testRunAfterBoth_sourceCancelled1() {
1684          for (ExecutionMode m : ExecutionMode.values())
1685          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1686 <        for (Integer v1 : new Integer[] { 1, null }) {
1687 <
1686 >        for (Integer v1 : new Integer[] { 1, null })
1687 >    {
1688          final CompletableFuture<Integer> f = new CompletableFuture<>();
1689          final CompletableFuture<Integer> g = new CompletableFuture<>();
1690          final Noop r = new Noop();
# Line 1782 | Line 1696 | public class CompletableFutureTest exten
1696  
1697          checkCompletedWithWrappedCancellationException(h);
1698          checkCancelled(f);
1699 <        assertEquals(r.invocationCount, 0);
1699 >        assertEquals(0, r.invocationCount);
1700          checkCompletedNormally(g, v1);
1701 <        }
1788 <    }
1701 >    }}
1702  
1703      public void testRunAfterBoth_sourceCancelled2() {
1704          for (ExecutionMode m : ExecutionMode.values())
1705          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1706 <        for (Integer v1 : new Integer[] { 1, null }) {
1707 <
1706 >        for (Integer v1 : new Integer[] { 1, null })
1707 >    {
1708          final CompletableFuture<Integer> f = new CompletableFuture<>();
1709          final CompletableFuture<Integer> g = new CompletableFuture<>();
1710          final Noop r = new Noop();
# Line 1803 | Line 1716 | public class CompletableFutureTest exten
1716  
1717          checkCompletedWithWrappedCancellationException(h);
1718          checkCancelled(g);
1719 <        assertEquals(r.invocationCount, 0);
1719 >        assertEquals(0, r.invocationCount);
1720          checkCompletedNormally(f, v1);
1721 <        }
1809 <    }
1721 >    }}
1722  
1723      public void testRunAfterBoth_sourceCancelled3() {
1724          for (ExecutionMode m : ExecutionMode.values())
1725          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1726 <        for (Integer v1 : new Integer[] { 1, null }) {
1727 <
1726 >        for (Integer v1 : new Integer[] { 1, null })
1727 >    {
1728          final CompletableFuture<Integer> f = new CompletableFuture<>();
1729          final CompletableFuture<Integer> g = new CompletableFuture<>();
1730          final Noop r = new Noop();
# Line 1823 | Line 1735 | public class CompletableFutureTest exten
1735  
1736          checkCompletedWithWrappedCancellationException(h);
1737          checkCancelled(g);
1738 <        assertEquals(r.invocationCount, 0);
1738 >        assertEquals(0, r.invocationCount);
1739          checkCompletedNormally(f, v1);
1740 <        }
1829 <    }
1740 >    }}
1741  
1742      public void testRunAfterBoth_sourceCancelled4() {
1743          for (ExecutionMode m : ExecutionMode.values())
1744          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1745 <        for (Integer v1 : new Integer[] { 1, null }) {
1746 <
1745 >        for (Integer v1 : new Integer[] { 1, null })
1746 >    {
1747          final CompletableFuture<Integer> f = new CompletableFuture<>();
1748          final CompletableFuture<Integer> g = new CompletableFuture<>();
1749          final Noop r = new Noop();
# Line 1843 | Line 1754 | public class CompletableFutureTest exten
1754  
1755          checkCompletedWithWrappedCancellationException(h);
1756          checkCancelled(f);
1757 <        assertEquals(r.invocationCount, 0);
1757 >        assertEquals(0, r.invocationCount);
1758          checkCompletedNormally(g, v1);
1759 <        }
1849 <    }
1759 >    }}
1760  
1761      /**
1762       * applyToEither result completes normally after normal completion
# Line 1855 | Line 1765 | public class CompletableFutureTest exten
1765      public void testApplyToEither_normalCompletion1() {
1766          for (ExecutionMode m : ExecutionMode.values())
1767          for (Integer v1 : new Integer[] { 1, null })
1768 <        for (Integer v2 : new Integer[] { 2, null }) {
1769 <
1768 >        for (Integer v2 : new Integer[] { 2, null })
1769 >    {
1770          final CompletableFuture<Integer> f = new CompletableFuture<>();
1771          final CompletableFuture<Integer> g = new CompletableFuture<>();
1772          final IncFunction r = new IncFunction();
# Line 1869 | Line 1779 | public class CompletableFutureTest exten
1779          checkCompletedNormally(f, v1);
1780          checkCompletedNormally(g, v2);
1781          checkCompletedNormally(h, inc(v1));
1782 <        }
1873 <    }
1782 >    }}
1783  
1784      public void testApplyToEither_normalCompletion2() {
1785          for (ExecutionMode m : ExecutionMode.values())
1786          for (Integer v1 : new Integer[] { 1, null })
1787 <        for (Integer v2 : new Integer[] { 2, null }) {
1788 <
1787 >        for (Integer v2 : new Integer[] { 2, null })
1788 >    {
1789          final CompletableFuture<Integer> f = new CompletableFuture<>();
1790          final CompletableFuture<Integer> g = new CompletableFuture<>();
1791          final IncFunction r = new IncFunction();
# Line 1889 | Line 1798 | public class CompletableFutureTest exten
1798          checkCompletedNormally(f, v1);
1799          checkCompletedNormally(g, v2);
1800          checkCompletedNormally(h, inc(v2));
1801 <        }
1802 <    }
1801 >        }}
1802 >
1803      public void testApplyToEither_normalCompletion3() {
1804          for (ExecutionMode m : ExecutionMode.values())
1805          for (Integer v1 : new Integer[] { 1, null })
1806 <        for (Integer v2 : new Integer[] { 2, null }) {
1807 <
1806 >        for (Integer v2 : new Integer[] { 2, null })
1807 >    {
1808          final CompletableFuture<Integer> f = new CompletableFuture<>();
1809          final CompletableFuture<Integer> g = new CompletableFuture<>();
1810          final IncFunction r = new IncFunction();
# Line 1910 | Line 1819 | public class CompletableFutureTest exten
1819          // unspecified behavior
1820          assertTrue(Objects.equals(h.join(), inc(v1)) ||
1821                     Objects.equals(h.join(), inc(v2)));
1822 <        assertEquals(r.invocationCount, 1);
1823 <        }
1915 <    }
1822 >        assertEquals(1, r.invocationCount);
1823 >    }}
1824  
1825      /**
1826       * applyToEither result completes exceptionally after exceptional
# Line 1920 | Line 1828 | public class CompletableFutureTest exten
1828       */
1829      public void testApplyToEither_exceptionalCompletion1() {
1830          for (ExecutionMode m : ExecutionMode.values())
1831 <        for (Integer v1 : new Integer[] { 1, null }) {
1832 <
1831 >        for (Integer v1 : new Integer[] { 1, null })
1832 >    {
1833          final CompletableFuture<Integer> f = new CompletableFuture<>();
1834          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835          final IncFunction r = new IncFunction();
# Line 1932 | Line 1840 | public class CompletableFutureTest exten
1840          checkCompletedWithWrappedCFException(h, ex);
1841          g.complete(v1);
1842  
1843 <        assertEquals(r.invocationCount, 0);
1843 >        assertEquals(0, r.invocationCount);
1844          checkCompletedNormally(g, v1);
1845          checkCompletedWithWrappedCFException(f, ex);
1846          checkCompletedWithWrappedCFException(h, ex);
1847 <        }
1940 <    }
1847 >    }}
1848  
1849      public void testApplyToEither_exceptionalCompletion2() {
1850          for (ExecutionMode m : ExecutionMode.values())
1851 <        for (Integer v1 : new Integer[] { 1, null }) {
1852 <
1851 >        for (Integer v1 : new Integer[] { 1, null })
1852 >    {
1853          final CompletableFuture<Integer> f = new CompletableFuture<>();
1854          final CompletableFuture<Integer> g = new CompletableFuture<>();
1855          final IncFunction r = new IncFunction();
# Line 1953 | Line 1860 | public class CompletableFutureTest exten
1860          checkCompletedWithWrappedCFException(h, ex);
1861          f.complete(v1);
1862  
1863 <        assertEquals(r.invocationCount, 0);
1863 >        assertEquals(0, r.invocationCount);
1864          checkCompletedNormally(f, v1);
1865          checkCompletedWithWrappedCFException(g, ex);
1866          checkCompletedWithWrappedCFException(h, ex);
1867 <        }
1961 <    }
1867 >    }}
1868  
1869      public void testApplyToEither_exceptionalCompletion3() {
1870          for (ExecutionMode m : ExecutionMode.values())
1871 <        for (Integer v1 : new Integer[] { 1, null }) {
1872 <
1871 >        for (Integer v1 : new Integer[] { 1, null })
1872 >    {
1873          final CompletableFuture<Integer> f = new CompletableFuture<>();
1874          final CompletableFuture<Integer> g = new CompletableFuture<>();
1875          final IncFunction r = new IncFunction();
# Line 1976 | Line 1882 | public class CompletableFutureTest exten
1882          // unspecified behavior
1883          Integer v;
1884          try {
1885 <            assertEquals(h.join(), inc(v1));
1886 <            assertEquals(r.invocationCount, 1);
1885 >            assertEquals(inc(v1), h.join());
1886 >            assertEquals(1, r.invocationCount);
1887          } catch (CompletionException ok) {
1888              checkCompletedWithWrappedCFException(h, ex);
1889 <            assertEquals(r.invocationCount, 0);
1889 >            assertEquals(0, r.invocationCount);
1890          }
1891  
1892          checkCompletedWithWrappedCFException(g, ex);
1893          checkCompletedNormally(f, v1);
1894 <        }
1989 <    }
1894 >    }}
1895  
1896      public void testApplyToEither_exceptionalCompletion4() {
1897          for (ExecutionMode m : ExecutionMode.values())
1898 <        for (Integer v1 : new Integer[] { 1, null }) {
1899 <
1898 >        for (Integer v1 : new Integer[] { 1, null })
1899 >    {
1900          final CompletableFuture<Integer> f = new CompletableFuture<>();
1901          final CompletableFuture<Integer> g = new CompletableFuture<>();
1902          final IncFunction r = new IncFunction();
# Line 2004 | Line 1909 | public class CompletableFutureTest exten
1909          // unspecified behavior
1910          Integer v;
1911          try {
1912 <            assertEquals(h.join(), inc(v1));
1913 <            assertEquals(r.invocationCount, 1);
1912 >            assertEquals(inc(v1), h.join());
1913 >            assertEquals(1, r.invocationCount);
1914          } catch (CompletionException ok) {
1915              checkCompletedWithWrappedCFException(h, ex);
1916 <            assertEquals(r.invocationCount, 0);
1916 >            assertEquals(0, r.invocationCount);
1917          }
1918  
1919          checkCompletedWithWrappedCFException(f, ex);
1920          checkCompletedNormally(g, v1);
1921 <        }
2017 <    }
1921 >    }}
1922  
1923      /**
1924       * applyToEither result completes exceptionally if action does
# Line 2022 | Line 1926 | public class CompletableFutureTest exten
1926      public void testApplyToEither_actionFailed1() {
1927          for (ExecutionMode m : ExecutionMode.values())
1928          for (Integer v1 : new Integer[] { 1, null })
1929 <        for (Integer v2 : new Integer[] { 2, null }) {
1930 <
1929 >        for (Integer v2 : new Integer[] { 2, null })
1930 >    {
1931          final CompletableFuture<Integer> f = new CompletableFuture<>();
1932          final CompletableFuture<Integer> g = new CompletableFuture<>();
1933          final FailingFunction r = new FailingFunction();
# Line 2034 | Line 1938 | public class CompletableFutureTest exten
1938          g.complete(v2);
1939          checkCompletedNormally(f, v1);
1940          checkCompletedNormally(g, v2);
1941 <        }
2038 <    }
1941 >    }}
1942  
1943      public void testApplyToEither_actionFailed2() {
1944          for (ExecutionMode m : ExecutionMode.values())
1945          for (Integer v1 : new Integer[] { 1, null })
1946 <        for (Integer v2 : new Integer[] { 2, null }) {
1947 <
1946 >        for (Integer v2 : new Integer[] { 2, null })
1947 >    {
1948          final CompletableFuture<Integer> f = new CompletableFuture<>();
1949          final CompletableFuture<Integer> g = new CompletableFuture<>();
1950          final FailingFunction r = new FailingFunction();
# Line 2052 | Line 1955 | public class CompletableFutureTest exten
1955          f.complete(v1);
1956          checkCompletedNormally(f, v1);
1957          checkCompletedNormally(g, v2);
1958 <        }
2056 <    }
1958 >    }}
1959  
1960      /**
1961       * applyToEither result completes exceptionally if either source cancelled
# Line 2061 | Line 1963 | public class CompletableFutureTest exten
1963      public void testApplyToEither_sourceCancelled1() {
1964          for (ExecutionMode m : ExecutionMode.values())
1965          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1966 <        for (Integer v1 : new Integer[] { 1, null }) {
1967 <
1966 >        for (Integer v1 : new Integer[] { 1, null })
1967 >    {
1968          final CompletableFuture<Integer> f = new CompletableFuture<>();
1969          final CompletableFuture<Integer> g = new CompletableFuture<>();
1970          final IncFunction r = new IncFunction();
# Line 2073 | Line 1975 | public class CompletableFutureTest exten
1975          g.complete(v1);
1976  
1977          checkCancelled(f);
1978 <        assertEquals(r.invocationCount, 0);
1978 >        assertEquals(0, r.invocationCount);
1979          checkCompletedNormally(g, v1);
1980          checkCompletedWithWrappedCancellationException(h);
1981 <        }
2080 <    }
1981 >    }}
1982  
1983      public void testApplyToEither_sourceCancelled2() {
1984          for (ExecutionMode m : ExecutionMode.values())
1985          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1986 <        for (Integer v1 : new Integer[] { 1, null }) {
1987 <
1986 >        for (Integer v1 : new Integer[] { 1, null })
1987 >    {
1988          final CompletableFuture<Integer> f = new CompletableFuture<>();
1989          final CompletableFuture<Integer> g = new CompletableFuture<>();
1990          final IncFunction r = new IncFunction();
# Line 2094 | Line 1995 | public class CompletableFutureTest exten
1995          f.complete(v1);
1996  
1997          checkCancelled(g);
1998 <        assertEquals(r.invocationCount, 0);
1998 >        assertEquals(0, r.invocationCount);
1999          checkCompletedNormally(f, v1);
2000          checkCompletedWithWrappedCancellationException(h);
2001 <        }
2101 <    }
2001 >    }}
2002  
2003      public void testApplyToEither_sourceCancelled3() {
2004          for (ExecutionMode m : ExecutionMode.values())
2005          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2006 <        for (Integer v1 : new Integer[] { 1, null }) {
2007 <
2006 >        for (Integer v1 : new Integer[] { 1, null })
2007 >    {
2008          final CompletableFuture<Integer> f = new CompletableFuture<>();
2009          final CompletableFuture<Integer> g = new CompletableFuture<>();
2010          final IncFunction r = new IncFunction();
# Line 2116 | Line 2016 | public class CompletableFutureTest exten
2016          // unspecified behavior
2017          Integer v;
2018          try {
2019 <            assertEquals(h.join(), inc(v1));
2020 <            assertEquals(r.invocationCount, 1);
2019 >            assertEquals(inc(v1), h.join());
2020 >            assertEquals(1, r.invocationCount);
2021          } catch (CompletionException ok) {
2022              checkCompletedWithWrappedCancellationException(h);
2023 <            assertEquals(r.invocationCount, 0);
2023 >            assertEquals(0, r.invocationCount);
2024          }
2025  
2026          checkCancelled(g);
2027          checkCompletedNormally(f, v1);
2028 <        }
2129 <    }
2028 >    }}
2029  
2030      public void testApplyToEither_sourceCancelled4() {
2031          for (ExecutionMode m : ExecutionMode.values())
2032          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2033 <        for (Integer v1 : new Integer[] { 1, null }) {
2034 <
2033 >        for (Integer v1 : new Integer[] { 1, null })
2034 >    {
2035          final CompletableFuture<Integer> f = new CompletableFuture<>();
2036          final CompletableFuture<Integer> g = new CompletableFuture<>();
2037          final IncFunction r = new IncFunction();
# Line 2144 | Line 2043 | public class CompletableFutureTest exten
2043          // unspecified behavior
2044          Integer v;
2045          try {
2046 <            assertEquals(h.join(), inc(v1));
2047 <            assertEquals(r.invocationCount, 1);
2046 >            assertEquals(inc(v1), h.join());
2047 >            assertEquals(1, r.invocationCount);
2048          } catch (CompletionException ok) {
2049              checkCompletedWithWrappedCancellationException(h);
2050 <            assertEquals(r.invocationCount, 0);
2050 >            assertEquals(0, r.invocationCount);
2051          }
2052  
2053          checkCancelled(f);
2054          checkCompletedNormally(g, v1);
2055 <        }
2157 <    }
2055 >    }}
2056  
2057      /**
2058       * acceptEither result completes normally after normal completion
# Line 2163 | Line 2061 | public class CompletableFutureTest exten
2061      public void testAcceptEither_normalCompletion1() {
2062          for (ExecutionMode m : ExecutionMode.values())
2063          for (Integer v1 : new Integer[] { 1, null })
2064 <        for (Integer v2 : new Integer[] { 2, null }) {
2065 <
2064 >        for (Integer v2 : new Integer[] { 2, null })
2065 >    {
2066          final CompletableFuture<Integer> f = new CompletableFuture<>();
2067          final CompletableFuture<Integer> g = new CompletableFuture<>();
2068          final IncAction r = new IncAction();
# Line 2172 | Line 2070 | public class CompletableFutureTest exten
2070  
2071          f.complete(v1);
2072          checkCompletedNormally(h, null);
2073 <        assertEquals(r.value, inc(v1));
2073 >        assertEquals(inc(v1), r.value);
2074          g.complete(v2);
2075  
2076          checkCompletedNormally(f, v1);
2077          checkCompletedNormally(g, v2);
2078          checkCompletedNormally(h, null);
2079 <        }
2182 <    }
2079 >    }}
2080  
2081      public void testAcceptEither_normalCompletion2() {
2082          for (ExecutionMode m : ExecutionMode.values())
2083          for (Integer v1 : new Integer[] { 1, null })
2084 <        for (Integer v2 : new Integer[] { 2, null }) {
2085 <
2084 >        for (Integer v2 : new Integer[] { 2, null })
2085 >    {
2086          final CompletableFuture<Integer> f = new CompletableFuture<>();
2087          final CompletableFuture<Integer> g = new CompletableFuture<>();
2088          final IncAction r = new IncAction();
# Line 2193 | Line 2090 | public class CompletableFutureTest exten
2090  
2091          g.complete(v2);
2092          checkCompletedNormally(h, null);
2093 <        assertEquals(r.value, inc(v2));
2093 >        assertEquals(inc(v2), r.value);
2094          f.complete(v1);
2095  
2096          checkCompletedNormally(f, v1);
2097          checkCompletedNormally(g, v2);
2098          checkCompletedNormally(h, null);
2099 <        }
2100 <    }
2099 >    }}
2100 >
2101      public void testAcceptEither_normalCompletion3() {
2102          for (ExecutionMode m : ExecutionMode.values())
2103          for (Integer v1 : new Integer[] { 1, null })
2104 <        for (Integer v2 : new Integer[] { 2, null }) {
2105 <
2104 >        for (Integer v2 : new Integer[] { 2, null })
2105 >    {
2106          final CompletableFuture<Integer> f = new CompletableFuture<>();
2107          final CompletableFuture<Integer> g = new CompletableFuture<>();
2108          final IncAction r = new IncAction();
# Line 2221 | Line 2118 | public class CompletableFutureTest exten
2118          // unspecified behavior
2119          assertTrue(Objects.equals(r.value, inc(v1)) ||
2120                     Objects.equals(r.value, inc(v2)));
2121 <        }
2225 <    }
2121 >    }}
2122  
2123      /**
2124       * acceptEither result completes exceptionally after exceptional
# Line 2230 | Line 2126 | public class CompletableFutureTest exten
2126       */
2127      public void testAcceptEither_exceptionalCompletion1() {
2128          for (ExecutionMode m : ExecutionMode.values())
2129 <        for (Integer v1 : new Integer[] { 1, null }) {
2130 <
2129 >        for (Integer v1 : new Integer[] { 1, null })
2130 >    {
2131          final CompletableFuture<Integer> f = new CompletableFuture<>();
2132          final CompletableFuture<Integer> g = new CompletableFuture<>();
2133          final IncAction r = new IncAction();
# Line 2242 | Line 2138 | public class CompletableFutureTest exten
2138          checkCompletedWithWrappedCFException(h, ex);
2139          g.complete(v1);
2140  
2141 <        assertEquals(r.invocationCount, 0);
2141 >        assertEquals(0, r.invocationCount);
2142          checkCompletedNormally(g, v1);
2143          checkCompletedWithWrappedCFException(f, ex);
2144          checkCompletedWithWrappedCFException(h, ex);
2145 <        }
2250 <    }
2145 >    }}
2146  
2147      public void testAcceptEither_exceptionalCompletion2() {
2148          for (ExecutionMode m : ExecutionMode.values())
2149 <        for (Integer v1 : new Integer[] { 1, null }) {
2150 <
2149 >        for (Integer v1 : new Integer[] { 1, null })
2150 >    {
2151          final CompletableFuture<Integer> f = new CompletableFuture<>();
2152          final CompletableFuture<Integer> g = new CompletableFuture<>();
2153          final IncAction r = new IncAction();
# Line 2263 | Line 2158 | public class CompletableFutureTest exten
2158          checkCompletedWithWrappedCFException(h, ex);
2159          f.complete(v1);
2160  
2161 <        assertEquals(r.invocationCount, 0);
2161 >        assertEquals(0, r.invocationCount);
2162          checkCompletedNormally(f, v1);
2163          checkCompletedWithWrappedCFException(g, ex);
2164          checkCompletedWithWrappedCFException(h, ex);
2165 <        }
2271 <    }
2165 >    }}
2166  
2167      public void testAcceptEither_exceptionalCompletion3() {
2168          for (ExecutionMode m : ExecutionMode.values())
2169 <        for (Integer v1 : new Integer[] { 1, null }) {
2170 <
2169 >        for (Integer v1 : new Integer[] { 1, null })
2170 >    {
2171          final CompletableFuture<Integer> f = new CompletableFuture<>();
2172          final CompletableFuture<Integer> g = new CompletableFuture<>();
2173          final IncAction r = new IncAction();
# Line 2286 | Line 2180 | public class CompletableFutureTest exten
2180          // unspecified behavior
2181          Integer v;
2182          try {
2183 <            assertEquals(h.join(), null);
2184 <            assertEquals(r.invocationCount, 1);
2183 >            assertNull(h.join());
2184 >            assertEquals(1, r.invocationCount);
2185              assertEquals(inc(v1), r.value);
2186          } catch (CompletionException ok) {
2187              checkCompletedWithWrappedCFException(h, ex);
2188 <            assertEquals(r.invocationCount, 0);
2188 >            assertEquals(0, r.invocationCount);
2189          }
2190  
2191          checkCompletedWithWrappedCFException(g, ex);
2192          checkCompletedNormally(f, v1);
2193 <        }
2300 <    }
2193 >    }}
2194  
2195      public void testAcceptEither_exceptionalCompletion4() {
2196          for (ExecutionMode m : ExecutionMode.values())
2197 <        for (Integer v1 : new Integer[] { 1, null }) {
2198 <
2197 >        for (Integer v1 : new Integer[] { 1, null })
2198 >    {
2199          final CompletableFuture<Integer> f = new CompletableFuture<>();
2200          final CompletableFuture<Integer> g = new CompletableFuture<>();
2201          final IncAction r = new IncAction();
# Line 2315 | Line 2208 | public class CompletableFutureTest exten
2208          // unspecified behavior
2209          Integer v;
2210          try {
2211 <            assertEquals(h.join(), null);
2212 <            assertEquals(r.invocationCount, 1);
2211 >            assertNull(h.join());
2212 >            assertEquals(1, r.invocationCount);
2213              assertEquals(inc(v1), r.value);
2214          } catch (CompletionException ok) {
2215              checkCompletedWithWrappedCFException(h, ex);
2216 <            assertEquals(r.invocationCount, 0);
2216 >            assertEquals(0, r.invocationCount);
2217          }
2218  
2219          checkCompletedWithWrappedCFException(f, ex);
2220          checkCompletedNormally(g, v1);
2221 <        }
2329 <    }
2221 >    }}
2222  
2223      /**
2224       * acceptEither result completes exceptionally if action does
# Line 2334 | Line 2226 | public class CompletableFutureTest exten
2226      public void testAcceptEither_actionFailed1() {
2227          for (ExecutionMode m : ExecutionMode.values())
2228          for (Integer v1 : new Integer[] { 1, null })
2229 <        for (Integer v2 : new Integer[] { 2, null }) {
2230 <
2229 >        for (Integer v2 : new Integer[] { 2, null })
2230 >    {
2231          final CompletableFuture<Integer> f = new CompletableFuture<>();
2232          final CompletableFuture<Integer> g = new CompletableFuture<>();
2233          final FailingConsumer r = new FailingConsumer();
# Line 2346 | Line 2238 | public class CompletableFutureTest exten
2238          g.complete(v2);
2239          checkCompletedNormally(f, v1);
2240          checkCompletedNormally(g, v2);
2241 <        }
2350 <    }
2241 >    }}
2242  
2243      public void testAcceptEither_actionFailed2() {
2244          for (ExecutionMode m : ExecutionMode.values())
2245          for (Integer v1 : new Integer[] { 1, null })
2246 <        for (Integer v2 : new Integer[] { 2, null }) {
2247 <
2246 >        for (Integer v2 : new Integer[] { 2, null })
2247 >    {
2248          final CompletableFuture<Integer> f = new CompletableFuture<>();
2249          final CompletableFuture<Integer> g = new CompletableFuture<>();
2250          final FailingConsumer r = new FailingConsumer();
# Line 2364 | Line 2255 | public class CompletableFutureTest exten
2255          f.complete(v1);
2256          checkCompletedNormally(f, v1);
2257          checkCompletedNormally(g, v2);
2258 <        }
2368 <    }
2258 >    }}
2259  
2260      /**
2261       * acceptEither result completes exceptionally if either source cancelled
# Line 2373 | Line 2263 | public class CompletableFutureTest exten
2263      public void testAcceptEither_sourceCancelled1() {
2264          for (ExecutionMode m : ExecutionMode.values())
2265          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2266 <        for (Integer v1 : new Integer[] { 1, null }) {
2267 <
2266 >        for (Integer v1 : new Integer[] { 1, null })
2267 >    {
2268          final CompletableFuture<Integer> f = new CompletableFuture<>();
2269          final CompletableFuture<Integer> g = new CompletableFuture<>();
2270          final IncAction r = new IncAction();
# Line 2385 | Line 2275 | public class CompletableFutureTest exten
2275          g.complete(v1);
2276  
2277          checkCancelled(f);
2278 <        assertEquals(r.invocationCount, 0);
2278 >        assertEquals(0, r.invocationCount);
2279          checkCompletedNormally(g, v1);
2280          checkCompletedWithWrappedCancellationException(h);
2281 <        }
2392 <    }
2281 >    }}
2282  
2283      public void testAcceptEither_sourceCancelled2() {
2284          for (ExecutionMode m : ExecutionMode.values())
2285          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2286 <        for (Integer v1 : new Integer[] { 1, null }) {
2287 <
2286 >        for (Integer v1 : new Integer[] { 1, null })
2287 >    {
2288          final CompletableFuture<Integer> f = new CompletableFuture<>();
2289          final CompletableFuture<Integer> g = new CompletableFuture<>();
2290          final IncAction r = new IncAction();
# Line 2406 | Line 2295 | public class CompletableFutureTest exten
2295          f.complete(v1);
2296  
2297          checkCancelled(g);
2298 <        assertEquals(r.invocationCount, 0);
2298 >        assertEquals(0, r.invocationCount);
2299          checkCompletedNormally(f, v1);
2300          checkCompletedWithWrappedCancellationException(h);
2301 <        }
2413 <    }
2301 >    }}
2302  
2303      public void testAcceptEither_sourceCancelled3() {
2304          for (ExecutionMode m : ExecutionMode.values())
2305          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2306 <        for (Integer v1 : new Integer[] { 1, null }) {
2307 <
2306 >        for (Integer v1 : new Integer[] { 1, null })
2307 >    {
2308          final CompletableFuture<Integer> f = new CompletableFuture<>();
2309          final CompletableFuture<Integer> g = new CompletableFuture<>();
2310          final IncAction r = new IncAction();
# Line 2428 | Line 2316 | public class CompletableFutureTest exten
2316          // unspecified behavior
2317          Integer v;
2318          try {
2319 <            assertEquals(h.join(), null);
2320 <            assertEquals(r.invocationCount, 1);
2319 >            assertNull(h.join());
2320 >            assertEquals(1, r.invocationCount);
2321              assertEquals(inc(v1), r.value);
2322          } catch (CompletionException ok) {
2323              checkCompletedWithWrappedCancellationException(h);
2324 <            assertEquals(r.invocationCount, 0);
2324 >            assertEquals(0, r.invocationCount);
2325          }
2326  
2327          checkCancelled(g);
2328          checkCompletedNormally(f, v1);
2329 <        }
2442 <    }
2329 >    }}
2330  
2331      public void testAcceptEither_sourceCancelled4() {
2332          for (ExecutionMode m : ExecutionMode.values())
2333          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2334 <        for (Integer v1 : new Integer[] { 1, null }) {
2335 <
2334 >        for (Integer v1 : new Integer[] { 1, null })
2335 >    {
2336          final CompletableFuture<Integer> f = new CompletableFuture<>();
2337          final CompletableFuture<Integer> g = new CompletableFuture<>();
2338          final IncAction r = new IncAction();
# Line 2457 | Line 2344 | public class CompletableFutureTest exten
2344          // unspecified behavior
2345          Integer v;
2346          try {
2347 <            assertEquals(h.join(), null);
2348 <            assertEquals(r.invocationCount, 1);
2347 >            assertNull(h.join());
2348 >            assertEquals(1, r.invocationCount);
2349              assertEquals(inc(v1), r.value);
2350          } catch (CompletionException ok) {
2351              checkCompletedWithWrappedCancellationException(h);
2352 <            assertEquals(r.invocationCount, 0);
2352 >            assertEquals(0, r.invocationCount);
2353          }
2354  
2355          checkCancelled(f);
2356          checkCompletedNormally(g, v1);
2357 <        }
2471 <    }
2357 >    }}
2358  
2359      /**
2360       * runAfterEither result completes normally after normal completion
# Line 2477 | Line 2363 | public class CompletableFutureTest exten
2363      public void testRunAfterEither_normalCompletion1() {
2364          for (ExecutionMode m : ExecutionMode.values())
2365          for (Integer v1 : new Integer[] { 1, null })
2366 <        for (Integer v2 : new Integer[] { 2, null }) {
2367 <
2366 >        for (Integer v2 : new Integer[] { 2, null })
2367 >    {
2368          final CompletableFuture<Integer> f = new CompletableFuture<>();
2369          final CompletableFuture<Integer> g = new CompletableFuture<>();
2370          final Noop r = new Noop();
# Line 2486 | Line 2372 | public class CompletableFutureTest exten
2372  
2373          f.complete(v1);
2374          checkCompletedNormally(h, null);
2375 <        assertEquals(r.invocationCount, 1);
2375 >        assertEquals(1, r.invocationCount);
2376          g.complete(v2);
2377  
2378          checkCompletedNormally(f, v1);
2379          checkCompletedNormally(g, v2);
2380          checkCompletedNormally(h, null);
2381 <        assertEquals(r.invocationCount, 1);
2382 <        }
2497 <    }
2381 >        assertEquals(1, r.invocationCount);
2382 >    }}
2383  
2384      public void testRunAfterEither_normalCompletion2() {
2385          for (ExecutionMode m : ExecutionMode.values())
2386          for (Integer v1 : new Integer[] { 1, null })
2387 <        for (Integer v2 : new Integer[] { 2, null }) {
2388 <
2387 >        for (Integer v2 : new Integer[] { 2, null })
2388 >    {
2389          final CompletableFuture<Integer> f = new CompletableFuture<>();
2390          final CompletableFuture<Integer> g = new CompletableFuture<>();
2391          final Noop r = new Noop();
# Line 2508 | Line 2393 | public class CompletableFutureTest exten
2393  
2394          g.complete(v2);
2395          checkCompletedNormally(h, null);
2396 <        assertEquals(r.invocationCount, 1);
2396 >        assertEquals(1, r.invocationCount);
2397          f.complete(v1);
2398  
2399          checkCompletedNormally(f, v1);
2400          checkCompletedNormally(g, v2);
2401          checkCompletedNormally(h, null);
2402 <        assertEquals(r.invocationCount, 1);
2403 <        }
2404 <    }
2402 >        assertEquals(1, r.invocationCount);
2403 >        }}
2404 >
2405      public void testRunAfterEither_normalCompletion3() {
2406          for (ExecutionMode m : ExecutionMode.values())
2407          for (Integer v1 : new Integer[] { 1, null })
2408 <        for (Integer v2 : new Integer[] { 2, null }) {
2409 <
2408 >        for (Integer v2 : new Integer[] { 2, null })
2409 >    {
2410          final CompletableFuture<Integer> f = new CompletableFuture<>();
2411          final CompletableFuture<Integer> g = new CompletableFuture<>();
2412          final Noop r = new Noop();
# Line 2533 | Line 2418 | public class CompletableFutureTest exten
2418          checkCompletedNormally(h, null);
2419          checkCompletedNormally(f, v1);
2420          checkCompletedNormally(g, v2);
2421 <        assertEquals(r.invocationCount, 1);
2422 <        }
2538 <    }
2421 >        assertEquals(1, r.invocationCount);
2422 >    }}
2423  
2424      /**
2425       * runAfterEither result completes exceptionally after exceptional
# Line 2543 | Line 2427 | public class CompletableFutureTest exten
2427       */
2428      public void testRunAfterEither_exceptionalCompletion1() {
2429          for (ExecutionMode m : ExecutionMode.values())
2430 <        for (Integer v1 : new Integer[] { 1, null }) {
2431 <
2430 >        for (Integer v1 : new Integer[] { 1, null })
2431 >    {
2432          final CompletableFuture<Integer> f = new CompletableFuture<>();
2433          final CompletableFuture<Integer> g = new CompletableFuture<>();
2434          final Noop r = new Noop();
# Line 2555 | Line 2439 | public class CompletableFutureTest exten
2439          checkCompletedWithWrappedCFException(h, ex);
2440          g.complete(v1);
2441  
2442 <        assertEquals(r.invocationCount, 0);
2442 >        assertEquals(0, r.invocationCount);
2443          checkCompletedNormally(g, v1);
2444          checkCompletedWithWrappedCFException(f, ex);
2445          checkCompletedWithWrappedCFException(h, ex);
2446 <        }
2563 <    }
2446 >    }}
2447  
2448      public void testRunAfterEither_exceptionalCompletion2() {
2449          for (ExecutionMode m : ExecutionMode.values())
2450 <        for (Integer v1 : new Integer[] { 1, null }) {
2451 <
2450 >        for (Integer v1 : new Integer[] { 1, null })
2451 >    {
2452          final CompletableFuture<Integer> f = new CompletableFuture<>();
2453          final CompletableFuture<Integer> g = new CompletableFuture<>();
2454          final Noop r = new Noop();
# Line 2576 | Line 2459 | public class CompletableFutureTest exten
2459          checkCompletedWithWrappedCFException(h, ex);
2460          f.complete(v1);
2461  
2462 <        assertEquals(r.invocationCount, 0);
2462 >        assertEquals(0, r.invocationCount);
2463          checkCompletedNormally(f, v1);
2464          checkCompletedWithWrappedCFException(g, ex);
2465          checkCompletedWithWrappedCFException(h, ex);
2466 <        }
2584 <    }
2466 >    }}
2467  
2468      public void testRunAfterEither_exceptionalCompletion3() {
2469          for (ExecutionMode m : ExecutionMode.values())
2470 <        for (Integer v1 : new Integer[] { 1, null }) {
2471 <
2470 >        for (Integer v1 : new Integer[] { 1, null })
2471 >    {
2472          final CompletableFuture<Integer> f = new CompletableFuture<>();
2473          final CompletableFuture<Integer> g = new CompletableFuture<>();
2474          final Noop r = new Noop();
# Line 2599 | Line 2481 | public class CompletableFutureTest exten
2481          // unspecified behavior
2482          Integer v;
2483          try {
2484 <            assertEquals(h.join(), null);
2485 <            assertEquals(r.invocationCount, 1);
2484 >            assertNull(h.join());
2485 >            assertEquals(1, r.invocationCount);
2486          } catch (CompletionException ok) {
2487              checkCompletedWithWrappedCFException(h, ex);
2488 <            assertEquals(r.invocationCount, 0);
2488 >            assertEquals(0, r.invocationCount);
2489          }
2490  
2491          checkCompletedWithWrappedCFException(g, ex);
2492          checkCompletedNormally(f, v1);
2493 <        }
2612 <    }
2493 >    }}
2494  
2495      public void testRunAfterEither_exceptionalCompletion4() {
2496          for (ExecutionMode m : ExecutionMode.values())
2497 <        for (Integer v1 : new Integer[] { 1, null }) {
2498 <
2497 >        for (Integer v1 : new Integer[] { 1, null })
2498 >    {
2499          final CompletableFuture<Integer> f = new CompletableFuture<>();
2500          final CompletableFuture<Integer> g = new CompletableFuture<>();
2501          final Noop r = new Noop();
# Line 2627 | Line 2508 | public class CompletableFutureTest exten
2508          // unspecified behavior
2509          Integer v;
2510          try {
2511 <            assertEquals(h.join(), null);
2512 <            assertEquals(r.invocationCount, 1);
2511 >            assertNull(h.join());
2512 >            assertEquals(1, r.invocationCount);
2513          } catch (CompletionException ok) {
2514              checkCompletedWithWrappedCFException(h, ex);
2515 <            assertEquals(r.invocationCount, 0);
2515 >            assertEquals(0, r.invocationCount);
2516          }
2517  
2518          checkCompletedWithWrappedCFException(f, ex);
2519          checkCompletedNormally(g, v1);
2520 <        }
2640 <    }
2520 >    }}
2521  
2522      /**
2523       * runAfterEither result completes exceptionally if action does
# Line 2645 | Line 2525 | public class CompletableFutureTest exten
2525      public void testRunAfterEither_actionFailed1() {
2526          for (ExecutionMode m : ExecutionMode.values())
2527          for (Integer v1 : new Integer[] { 1, null })
2528 <        for (Integer v2 : new Integer[] { 2, null }) {
2529 <
2528 >        for (Integer v2 : new Integer[] { 2, null })
2529 >    {
2530          final CompletableFuture<Integer> f = new CompletableFuture<>();
2531          final CompletableFuture<Integer> g = new CompletableFuture<>();
2532 <        final FailingNoop r = new FailingNoop();
2532 >        final FailingRunnable r = new FailingRunnable();
2533          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2534  
2535          f.complete(v1);
# Line 2657 | Line 2537 | public class CompletableFutureTest exten
2537          g.complete(v2);
2538          checkCompletedNormally(f, v1);
2539          checkCompletedNormally(g, v2);
2540 <        }
2661 <    }
2540 >    }}
2541  
2542      public void testRunAfterEither_actionFailed2() {
2543          for (ExecutionMode m : ExecutionMode.values())
2544          for (Integer v1 : new Integer[] { 1, null })
2545 <        for (Integer v2 : new Integer[] { 2, null }) {
2546 <
2545 >        for (Integer v2 : new Integer[] { 2, null })
2546 >    {
2547          final CompletableFuture<Integer> f = new CompletableFuture<>();
2548          final CompletableFuture<Integer> g = new CompletableFuture<>();
2549 <        final FailingNoop r = new FailingNoop();
2549 >        final FailingRunnable r = new FailingRunnable();
2550          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2551  
2552          g.complete(v2);
# Line 2675 | Line 2554 | public class CompletableFutureTest exten
2554          f.complete(v1);
2555          checkCompletedNormally(f, v1);
2556          checkCompletedNormally(g, v2);
2557 <        }
2679 <    }
2557 >    }}
2558  
2559      /**
2560       * runAfterEither result completes exceptionally if either source cancelled
# Line 2684 | Line 2562 | public class CompletableFutureTest exten
2562      public void testRunAfterEither_sourceCancelled1() {
2563          for (ExecutionMode m : ExecutionMode.values())
2564          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2565 <        for (Integer v1 : new Integer[] { 1, null }) {
2566 <
2565 >        for (Integer v1 : new Integer[] { 1, null })
2566 >    {
2567          final CompletableFuture<Integer> f = new CompletableFuture<>();
2568          final CompletableFuture<Integer> g = new CompletableFuture<>();
2569          final Noop r = new Noop();
# Line 2696 | Line 2574 | public class CompletableFutureTest exten
2574          g.complete(v1);
2575  
2576          checkCancelled(f);
2577 <        assertEquals(r.invocationCount, 0);
2577 >        assertEquals(0, r.invocationCount);
2578          checkCompletedNormally(g, v1);
2579          checkCompletedWithWrappedCancellationException(h);
2580 <        }
2703 <    }
2580 >    }}
2581  
2582      public void testRunAfterEither_sourceCancelled2() {
2583          for (ExecutionMode m : ExecutionMode.values())
2584          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2585 <        for (Integer v1 : new Integer[] { 1, null }) {
2586 <
2585 >        for (Integer v1 : new Integer[] { 1, null })
2586 >    {
2587          final CompletableFuture<Integer> f = new CompletableFuture<>();
2588          final CompletableFuture<Integer> g = new CompletableFuture<>();
2589          final Noop r = new Noop();
# Line 2717 | Line 2594 | public class CompletableFutureTest exten
2594          f.complete(v1);
2595  
2596          checkCancelled(g);
2597 <        assertEquals(r.invocationCount, 0);
2597 >        assertEquals(0, r.invocationCount);
2598          checkCompletedNormally(f, v1);
2599          checkCompletedWithWrappedCancellationException(h);
2600 <        }
2724 <    }
2600 >    }}
2601  
2602      public void testRunAfterEither_sourceCancelled3() {
2603          for (ExecutionMode m : ExecutionMode.values())
2604          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2605 <        for (Integer v1 : new Integer[] { 1, null }) {
2606 <
2605 >        for (Integer v1 : new Integer[] { 1, null })
2606 >    {
2607          final CompletableFuture<Integer> f = new CompletableFuture<>();
2608          final CompletableFuture<Integer> g = new CompletableFuture<>();
2609          final Noop r = new Noop();
# Line 2739 | Line 2615 | public class CompletableFutureTest exten
2615          // unspecified behavior
2616          Integer v;
2617          try {
2618 <            assertEquals(h.join(), null);
2619 <            assertEquals(r.invocationCount, 1);
2618 >            assertNull(h.join());
2619 >            assertEquals(1, r.invocationCount);
2620          } catch (CompletionException ok) {
2621              checkCompletedWithWrappedCancellationException(h);
2622 <            assertEquals(r.invocationCount, 0);
2622 >            assertEquals(0, r.invocationCount);
2623          }
2624  
2625          checkCancelled(g);
2626          checkCompletedNormally(f, v1);
2627 <        }
2752 <    }
2627 >    }}
2628  
2629      public void testRunAfterEither_sourceCancelled4() {
2630          for (ExecutionMode m : ExecutionMode.values())
2631          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2632 <        for (Integer v1 : new Integer[] { 1, null }) {
2633 <
2632 >        for (Integer v1 : new Integer[] { 1, null })
2633 >    {
2634          final CompletableFuture<Integer> f = new CompletableFuture<>();
2635          final CompletableFuture<Integer> g = new CompletableFuture<>();
2636          final Noop r = new Noop();
# Line 2767 | Line 2642 | public class CompletableFutureTest exten
2642          // unspecified behavior
2643          Integer v;
2644          try {
2645 <            assertEquals(h.join(), null);
2646 <            assertEquals(r.invocationCount, 1);
2645 >            assertNull(h.join());
2646 >            assertEquals(1, r.invocationCount);
2647          } catch (CompletionException ok) {
2648              checkCompletedWithWrappedCancellationException(h);
2649 <            assertEquals(r.invocationCount, 0);
2649 >            assertEquals(0, r.invocationCount);
2650          }
2651  
2652          checkCancelled(f);
2653          checkCompletedNormally(g, v1);
2654 <        }
2780 <    }
2654 >    }}
2655  
2656      /**
2657       * thenCompose result completes normally after normal completion of source
2658       */
2659 <    public void testThenCompose() {
2660 <        CompletableFuture<Integer> f, g;
2661 <        CompletableFutureInc r;
2662 <
2663 <        f = new CompletableFuture<>();
2664 <        g = f.thenCompose(r = new CompletableFutureInc());
2665 <        f.complete(one);
2666 <        checkCompletedNormally(g, two);
2667 <        assertTrue(r.ran);
2659 >    public void testThenCompose_normalCompletion() {
2660 >        for (ExecutionMode m : ExecutionMode.values())
2661 >        for (boolean createIncomplete : new boolean[] { true, false })
2662 >        for (Integer v1 : new Integer[] { 1, null })
2663 >    {
2664 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2665 >        final CompletableFutureInc r = new CompletableFutureInc();
2666 >        if (!createIncomplete) f.complete(v1);
2667 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2668 >        if (createIncomplete) f.complete(v1);
2669  
2670 <        f = new CompletableFuture<>();
2671 <        f.complete(one);
2672 <        g = f.thenCompose(r = new CompletableFutureInc());
2673 <        checkCompletedNormally(g, two);
2799 <        assertTrue(r.ran);
2800 <    }
2670 >        checkCompletedNormally(g, inc(v1));
2671 >        checkCompletedNormally(f, v1);
2672 >        assertEquals(1, r.invocationCount);
2673 >    }}
2674  
2675      /**
2676       * thenCompose result completes exceptionally after exceptional
2677       * completion of source
2678       */
2679 <    public void testThenCompose2() {
2680 <        CompletableFuture<Integer> f, g;
2681 <        CompletableFutureInc r;
2682 <
2683 <        f = new CompletableFuture<>();
2684 <        g = f.thenCompose(r = new CompletableFutureInc());
2685 <        f.completeExceptionally(new CFException());
2686 <        checkCompletedWithWrappedCFException(g);
2679 >    public void testThenCompose_exceptionalCompletion() {
2680 >        for (ExecutionMode m : ExecutionMode.values())
2681 >        for (boolean createIncomplete : new boolean[] { true, false })
2682 >    {
2683 >        final CFException ex = new CFException();
2684 >        final CompletableFutureInc r = new CompletableFutureInc();
2685 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2686 >        if (!createIncomplete) f.completeExceptionally(ex);
2687 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2688 >        if (createIncomplete) f.completeExceptionally(ex);
2689  
2690 <        f = new CompletableFuture<>();
2691 <        f.completeExceptionally(new CFException());
2692 <        g = f.thenCompose(r = new CompletableFutureInc());
2693 <        checkCompletedWithWrappedCFException(g);
2819 <    }
2690 >        checkCompletedWithWrappedCFException(g, ex);
2691 >        checkCompletedWithWrappedCFException(f, ex);
2692 >        assertEquals(0, r.invocationCount);
2693 >    }}
2694  
2695      /**
2696       * thenCompose result completes exceptionally if action does
2697       */
2698 <    public void testThenCompose3() {
2699 <        CompletableFuture<Integer> f, g;
2700 <        FailingCompletableFutureFunction r;
2701 <
2702 <        f = new CompletableFuture<>();
2703 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2704 <        f.complete(one);
2705 <        checkCompletedWithWrappedCFException(g);
2698 >    public void testThenCompose_actionFailed() {
2699 >        for (ExecutionMode m : ExecutionMode.values())
2700 >        for (boolean createIncomplete : new boolean[] { true, false })
2701 >        for (Integer v1 : new Integer[] { 1, null })
2702 >    {
2703 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2704 >        final FailingCompletableFutureFunction r
2705 >            = new FailingCompletableFutureFunction();
2706 >        if (!createIncomplete) f.complete(v1);
2707 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2708 >        if (createIncomplete) f.complete(v1);
2709  
2833 –        f = new CompletableFuture<>();
2834 –        f.complete(one);
2835 –        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2710          checkCompletedWithWrappedCFException(g);
2711 <    }
2711 >        checkCompletedNormally(f, v1);
2712 >    }}
2713  
2714      /**
2715       * thenCompose result completes exceptionally if source cancelled
2716       */
2717 <    public void testThenCompose4() {
2718 <        CompletableFuture<Integer> f, g;
2719 <        CompletableFutureInc r;
2720 <
2721 <        f = new CompletableFuture<>();
2722 <        g = f.thenCompose(r = new CompletableFutureInc());
2723 <        assertTrue(f.cancel(true));
2724 <        checkCompletedWithWrappedCancellationException(g);
2725 <
2726 <        f = new CompletableFuture<>();
2727 <        assertTrue(f.cancel(true));
2728 <        g = f.thenCompose(r = new CompletableFutureInc());
2729 <        checkCompletedWithWrappedCancellationException(g);
2855 <    }
2856 <
2857 <    // asyncs
2858 <
2859 <    /**
2860 <     * thenRunAsync result completes normally after normal completion of source
2861 <     */
2862 <    public void testThenRunAsync() {
2863 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2864 <        Noop r = new Noop();
2865 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2866 <        f.complete(null);
2867 <        checkCompletedNormally(g, null);
2868 <
2869 <        // reordered version
2870 <        f = new CompletableFuture<>();
2871 <        f.complete(null);
2872 <        r = new Noop();
2873 <        g = f.thenRunAsync(r);
2874 <        checkCompletedNormally(g, null);
2875 <    }
2876 <
2877 <    /**
2878 <     * thenRunAsync result completes exceptionally after exceptional
2879 <     * completion of source
2880 <     */
2881 <    public void testThenRunAsync2() {
2882 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2883 <        Noop r = new Noop();
2884 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2885 <        f.completeExceptionally(new CFException());
2886 <        try {
2887 <            g.join();
2888 <            shouldThrow();
2889 <        } catch (CompletionException success) {}
2890 <        checkCompletedWithWrappedCFException(g);
2891 <    }
2892 <
2893 <    /**
2894 <     * thenRunAsync result completes exceptionally if action does
2895 <     */
2896 <    public void testThenRunAsync3() {
2897 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2898 <        FailingNoop r = new FailingNoop();
2899 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2900 <        f.complete(null);
2901 <        checkCompletedWithWrappedCFException(g);
2902 <    }
2903 <
2904 <    /**
2905 <     * thenRunAsync result completes exceptionally if source cancelled
2906 <     */
2907 <    public void testThenRunAsync4() {
2908 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2909 <        Noop r = new Noop();
2910 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2911 <        assertTrue(f.cancel(true));
2912 <        checkCompletedWithWrappedCancellationException(g);
2913 <    }
2914 <
2915 <    /**
2916 <     * thenApplyAsync result completes normally after normal completion of source
2917 <     */
2918 <    public void testThenApplyAsync() {
2919 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2920 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2921 <        f.complete(one);
2922 <        checkCompletedNormally(g, two);
2923 <    }
2924 <
2925 <    /**
2926 <     * thenApplyAsync result completes exceptionally after exceptional
2927 <     * completion of source
2928 <     */
2929 <    public void testThenApplyAsync2() {
2930 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2931 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2932 <        f.completeExceptionally(new CFException());
2933 <        checkCompletedWithWrappedCFException(g);
2934 <    }
2935 <
2936 <    /**
2937 <     * thenApplyAsync result completes exceptionally if action does
2938 <     */
2939 <    public void testThenApplyAsync3() {
2940 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2941 <        FailingFunction r = new FailingFunction();
2942 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2943 <        f.complete(null);
2944 <        checkCompletedWithWrappedCFException(g);
2945 <    }
2946 <
2947 <    /**
2948 <     * thenApplyAsync result completes exceptionally if source cancelled
2949 <     */
2950 <    public void testThenApplyAsync4() {
2951 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2952 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2953 <        assertTrue(f.cancel(true));
2954 <        checkCompletedWithWrappedCancellationException(g);
2955 <    }
2956 <
2957 <    /**
2958 <     * thenAcceptAsync result completes normally after normal
2959 <     * completion of source
2960 <     */
2961 <    public void testThenAcceptAsync() {
2962 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2963 <        IncAction r = new IncAction();
2964 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2965 <        f.complete(one);
2966 <        checkCompletedNormally(g, null);
2967 <        assertEquals(r.value, (Integer) 2);
2968 <    }
2969 <
2970 <    /**
2971 <     * thenAcceptAsync result completes exceptionally after exceptional
2972 <     * completion of source
2973 <     */
2974 <    public void testThenAcceptAsync2() {
2975 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2976 <        IncAction r = new IncAction();
2977 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2978 <        f.completeExceptionally(new CFException());
2979 <        checkCompletedWithWrappedCFException(g);
2980 <    }
2981 <
2982 <    /**
2983 <     * thenAcceptAsync result completes exceptionally if action does
2984 <     */
2985 <    public void testThenAcceptAsync3() {
2986 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2987 <        FailingConsumer r = new FailingConsumer();
2988 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2989 <        f.complete(null);
2990 <        checkCompletedWithWrappedCFException(g);
2991 <    }
2992 <
2993 <    /**
2994 <     * thenAcceptAsync result completes exceptionally if source cancelled
2995 <     */
2996 <    public void testThenAcceptAsync4() {
2997 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2998 <        IncAction r = new IncAction();
2999 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3000 <        assertTrue(f.cancel(true));
3001 <        checkCompletedWithWrappedCancellationException(g);
3002 <    }
3003 <
3004 <    /**
3005 <     * thenComposeAsync result completes normally after normal
3006 <     * completion of source
3007 <     */
3008 <    public void testThenComposeAsync() {
3009 <        CompletableFuture<Integer> f, g;
3010 <        CompletableFutureInc r;
3011 <
3012 <        f = new CompletableFuture<>();
3013 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3014 <        f.complete(one);
3015 <        checkCompletedNormally(g, two);
3016 <
3017 <        f = new CompletableFuture<>();
3018 <        f.complete(one);
3019 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3020 <        checkCompletedNormally(g, two);
3021 <    }
3022 <
3023 <    /**
3024 <     * thenComposeAsync result completes exceptionally after
3025 <     * exceptional completion of source
3026 <     */
3027 <    public void testThenComposeAsync2() {
3028 <        CompletableFuture<Integer> f, g;
3029 <        CompletableFutureInc r;
3030 <
3031 <        f = new CompletableFuture<>();
3032 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3033 <        f.completeExceptionally(new CFException());
3034 <        checkCompletedWithWrappedCFException(g);
3035 <        assertFalse(r.ran);
3036 <
3037 <        f = new CompletableFuture<>();
3038 <        f.completeExceptionally(new CFException());
3039 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3040 <        checkCompletedWithWrappedCFException(g);
3041 <        assertFalse(r.ran);
3042 <    }
3043 <
3044 <    /**
3045 <     * thenComposeAsync result completes exceptionally if action does
3046 <     */
3047 <    public void testThenComposeAsync3() {
3048 <        CompletableFuture<Integer> f, g;
3049 <        FailingCompletableFutureFunction r;
3050 <
3051 <        f = new CompletableFuture<>();
3052 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3053 <        f.complete(one);
3054 <        checkCompletedWithWrappedCFException(g);
3055 <
3056 <        f = new CompletableFuture<>();
3057 <        f.complete(one);
3058 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3059 <        checkCompletedWithWrappedCFException(g);
3060 <    }
3061 <
3062 <    /**
3063 <     * thenComposeAsync result completes exceptionally if source cancelled
3064 <     */
3065 <    public void testThenComposeAsync4() {
3066 <        CompletableFuture<Integer> f, g;
3067 <        CompletableFutureInc r;
3068 <
3069 <        f = new CompletableFuture<>();
3070 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3071 <        assertTrue(f.cancel(true));
3072 <        checkCompletedWithWrappedCancellationException(g);
3073 <
3074 <        f = new CompletableFuture<>();
3075 <        assertTrue(f.cancel(true));
3076 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3077 <        checkCompletedWithWrappedCancellationException(g);
3078 <    }
3079 <
3080 <    // async with explicit executors
3081 <
3082 <    /**
3083 <     * thenRunAsync result completes normally after normal completion of source
3084 <     */
3085 <    public void testThenRunAsyncE() {
3086 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3087 <        Noop r = new Noop();
3088 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3089 <        f.complete(null);
3090 <        checkCompletedNormally(g, null);
3091 <
3092 <        // reordered version
3093 <        f = new CompletableFuture<>();
3094 <        f.complete(null);
3095 <        r = new Noop();
3096 <        g = f.thenRunAsync(r, new ThreadExecutor());
3097 <        checkCompletedNormally(g, null);
3098 <    }
3099 <
3100 <    /**
3101 <     * thenRunAsync result completes exceptionally after exceptional
3102 <     * completion of source
3103 <     */
3104 <    public void testThenRunAsync2E() {
3105 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3106 <        Noop r = new Noop();
3107 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3108 <        f.completeExceptionally(new CFException());
3109 <        try {
3110 <            g.join();
3111 <            shouldThrow();
3112 <        } catch (CompletionException success) {}
3113 <        checkCompletedWithWrappedCFException(g);
3114 <    }
3115 <
3116 <    /**
3117 <     * thenRunAsync result completes exceptionally if action does
3118 <     */
3119 <    public void testThenRunAsync3E() {
3120 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3121 <        FailingNoop r = new FailingNoop();
3122 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3123 <        f.complete(null);
3124 <        checkCompletedWithWrappedCFException(g);
3125 <    }
3126 <
3127 <    /**
3128 <     * thenRunAsync result completes exceptionally if source cancelled
3129 <     */
3130 <    public void testThenRunAsync4E() {
3131 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3132 <        Noop r = new Noop();
3133 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3134 <        assertTrue(f.cancel(true));
3135 <        checkCompletedWithWrappedCancellationException(g);
3136 <    }
3137 <
3138 <    /**
3139 <     * thenApplyAsync result completes normally after normal completion of source
3140 <     */
3141 <    public void testThenApplyAsyncE() {
3142 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3143 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3144 <        f.complete(one);
3145 <        checkCompletedNormally(g, two);
3146 <    }
3147 <
3148 <    /**
3149 <     * thenApplyAsync result completes exceptionally after exceptional
3150 <     * completion of source
3151 <     */
3152 <    public void testThenApplyAsync2E() {
3153 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3154 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3155 <        f.completeExceptionally(new CFException());
3156 <        checkCompletedWithWrappedCFException(g);
3157 <    }
3158 <
3159 <    /**
3160 <     * thenApplyAsync result completes exceptionally if action does
3161 <     */
3162 <    public void testThenApplyAsync3E() {
3163 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3164 <        FailingFunction r = new FailingFunction();
3165 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3166 <        f.complete(null);
3167 <        checkCompletedWithWrappedCFException(g);
3168 <    }
3169 <
3170 <    /**
3171 <     * thenApplyAsync result completes exceptionally if source cancelled
3172 <     */
3173 <    public void testThenApplyAsync4E() {
3174 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3175 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3176 <        assertTrue(f.cancel(true));
3177 <        checkCompletedWithWrappedCancellationException(g);
3178 <    }
3179 <
3180 <    /**
3181 <     * thenAcceptAsync result completes normally after normal
3182 <     * completion of source
3183 <     */
3184 <    public void testThenAcceptAsyncE() {
3185 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3186 <        IncAction r = new IncAction();
3187 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3188 <        f.complete(one);
3189 <        checkCompletedNormally(g, null);
3190 <        assertEquals(r.value, (Integer) 2);
3191 <    }
3192 <
3193 <    /**
3194 <     * thenAcceptAsync result completes exceptionally after exceptional
3195 <     * completion of source
3196 <     */
3197 <    public void testThenAcceptAsync2E() {
3198 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3199 <        IncAction r = new IncAction();
3200 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3201 <        f.completeExceptionally(new CFException());
3202 <        checkCompletedWithWrappedCFException(g);
3203 <    }
3204 <
3205 <    /**
3206 <     * thenAcceptAsync result completes exceptionally if action does
3207 <     */
3208 <    public void testThenAcceptAsync3E() {
3209 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3210 <        FailingConsumer r = new FailingConsumer();
3211 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3212 <        f.complete(null);
3213 <        checkCompletedWithWrappedCFException(g);
3214 <    }
3215 <
3216 <    /**
3217 <     * thenAcceptAsync result completes exceptionally if source cancelled
3218 <     */
3219 <    public void testThenAcceptAsync4E() {
3220 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3221 <        IncAction r = new IncAction();
3222 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3223 <        assertTrue(f.cancel(true));
3224 <        checkCompletedWithWrappedCancellationException(g);
3225 <    }
3226 <
3227 <    /**
3228 <     * thenComposeAsync result completes normally after normal
3229 <     * completion of source
3230 <     */
3231 <    public void testThenComposeAsyncE() {
3232 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3233 <        CompletableFutureInc r = new CompletableFutureInc();
3234 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3235 <        f.complete(one);
3236 <        checkCompletedNormally(g, two);
3237 <    }
3238 <
3239 <    /**
3240 <     * thenComposeAsync result completes exceptionally after
3241 <     * exceptional completion of source
3242 <     */
3243 <    public void testThenComposeAsync2E() {
3244 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3245 <        CompletableFutureInc r = new CompletableFutureInc();
3246 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3247 <        f.completeExceptionally(new CFException());
3248 <        checkCompletedWithWrappedCFException(g);
3249 <    }
3250 <
3251 <    /**
3252 <     * thenComposeAsync result completes exceptionally if action does
3253 <     */
3254 <    public void testThenComposeAsync3E() {
3255 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3256 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
3257 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3258 <        f.complete(one);
3259 <        checkCompletedWithWrappedCFException(g);
3260 <    }
2717 >    public void testThenCompose_sourceCancelled() {
2718 >        for (ExecutionMode m : ExecutionMode.values())
2719 >        for (boolean createIncomplete : new boolean[] { true, false })
2720 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2721 >    {
2722 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2723 >        final CompletableFutureInc r = new CompletableFutureInc();
2724 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2725 >        final CompletableFuture<Integer> g = f.thenCompose(r);
2726 >        if (createIncomplete) {
2727 >            checkIncomplete(g);
2728 >            assertTrue(f.cancel(mayInterruptIfRunning));
2729 >        }
2730  
3262 –    /**
3263 –     * thenComposeAsync result completes exceptionally if source cancelled
3264 –     */
3265 –    public void testThenComposeAsync4E() {
3266 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3267 –        CompletableFutureInc r = new CompletableFutureInc();
3268 –        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3269 –        assertTrue(f.cancel(true));
2731          checkCompletedWithWrappedCancellationException(g);
2732 <    }
2732 >        checkCancelled(f);
2733 >    }}
2734  
2735      // other static methods
2736  
# Line 3470 | Line 2932 | public class CompletableFutureTest exten
2932       */
2933      public void testWhenComplete_normalCompletion1() {
2934          for (ExecutionMode m : ExecutionMode.values())
2935 <        for (Integer v1 : new Integer[] { 1, null }) {
2936 <
2937 <        final AtomicInteger a = new AtomicInteger();
2935 >        for (boolean createIncomplete : new boolean[] { true, false })
2936 >        for (Integer v1 : new Integer[] { 1, null })
2937 >    {
2938 >        final AtomicInteger a = new AtomicInteger(0);
2939          final CompletableFuture<Integer> f = new CompletableFuture<>();
2940 <        final CompletableFuture<Integer> g =
2941 <            m.whenComplete(f,
2942 <                           (Integer x, Throwable t) -> {
2943 <                               threadAssertSame(x, v1);
2944 <                               threadAssertNull(t);
2945 <                               a.getAndIncrement();
2946 <                           });
2947 <        f.complete(v1);
2948 <        checkCompletedNormally(f, v1);
2940 >        if (!createIncomplete) f.complete(v1);
2941 >        final CompletableFuture<Integer> g = m.whenComplete
2942 >            (f,
2943 >             (Integer x, Throwable t) -> {
2944 >                threadAssertSame(x, v1);
2945 >                threadAssertNull(t);
2946 >                a.getAndIncrement();
2947 >            });
2948 >        if (createIncomplete) f.complete(v1);
2949 >
2950          checkCompletedNormally(g, v1);
2951 <        assertEquals(a.get(), 1);
2952 <        }
2953 <    }
2951 >        checkCompletedNormally(f, v1);
2952 >        assertEquals(1, a.get());
2953 >    }}
2954  
2955      /**
2956       * whenComplete action executes on exceptional completion, propagating
# Line 3494 | Line 2958 | public class CompletableFutureTest exten
2958       */
2959      public void testWhenComplete_exceptionalCompletion() {
2960          for (ExecutionMode m : ExecutionMode.values())
2961 <        for (Integer v1 : new Integer[] { 1, null }) {
2962 <
2963 <        final AtomicInteger a = new AtomicInteger();
2961 >        for (boolean createIncomplete : new boolean[] { true, false })
2962 >        for (Integer v1 : new Integer[] { 1, null })
2963 >    {
2964 >        final AtomicInteger a = new AtomicInteger(0);
2965          final CFException ex = new CFException();
2966          final CompletableFuture<Integer> f = new CompletableFuture<>();
2967 +        if (!createIncomplete) f.completeExceptionally(ex);
2968          final CompletableFuture<Integer> g = m.whenComplete
2969              (f,
2970               (Integer x, Throwable t) -> {
# Line 3506 | Line 2972 | public class CompletableFutureTest exten
2972                  threadAssertSame(t, ex);
2973                  a.getAndIncrement();
2974              });
2975 <        f.completeExceptionally(ex);
2975 >        if (createIncomplete) f.completeExceptionally(ex);
2976          checkCompletedWithWrappedCFException(f, ex);
2977          checkCompletedWithWrappedCFException(g, ex);
2978 <        assertEquals(a.get(), 1);
2979 <        }
2980 <    }
2978 >        assertEquals(1, a.get());
2979 >    }}
2980 >
2981 >    /**
2982 >     * whenComplete action executes on cancelled source, propagating
2983 >     * CancellationException.
2984 >     */
2985 >    public void testWhenComplete_sourceCancelled() {
2986 >        for (ExecutionMode m : ExecutionMode.values())
2987 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2988 >        for (boolean createIncomplete : new boolean[] { true, false })
2989 >    {
2990 >        final AtomicInteger a = new AtomicInteger(0);
2991 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2992 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2993 >        final CompletableFuture<Integer> g = m.whenComplete
2994 >            (f,
2995 >             (Integer x, Throwable t) -> {
2996 >                threadAssertNull(x);
2997 >                threadAssertTrue(t instanceof CancellationException);
2998 >                a.getAndIncrement();
2999 >            });
3000 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3001 >
3002 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
3003 >        checkCompletedWithWrappedCancellationException(g);
3004 >        checkCancelled(f);
3005 >        assertEquals(1, a.get());
3006 >    }}
3007  
3008      /**
3009       * If a whenComplete action throws an exception when triggered by
3010       * a normal completion, it completes exceptionally
3011       */
3012      public void testWhenComplete_actionFailed() {
3013 +        for (boolean createIncomplete : new boolean[] { true, false })
3014          for (ExecutionMode m : ExecutionMode.values())
3015 <        for (Integer v1 : new Integer[] { 1, null }) {
3016 <
3015 >        for (Integer v1 : new Integer[] { 1, null })
3016 >    {
3017 >        final AtomicInteger a = new AtomicInteger(0);
3018          final CFException ex = new CFException();
3019          final CompletableFuture<Integer> f = new CompletableFuture<>();
3020 +        if (!createIncomplete) f.complete(v1);
3021          final CompletableFuture<Integer> g = m.whenComplete
3022              (f,
3023               (Integer x, Throwable t) -> {
3024                  threadAssertSame(x, v1);
3025                  threadAssertNull(t);
3026 +                a.getAndIncrement();
3027                  throw ex;
3028              });
3029 <        f.complete(v1);
3029 >        if (createIncomplete) f.complete(v1);
3030          checkCompletedNormally(f, v1);
3031          checkCompletedWithWrappedCFException(g, ex);
3032 <        }
3033 <    }
3032 >        assertEquals(1, a.get());
3033 >    }}
3034  
3035      /**
3036       * If a whenComplete action throws an exception when triggered by
# Line 3542 | Line 3038 | public class CompletableFutureTest exten
3038       * exception takes precedence.
3039       */
3040      public void testWhenComplete_actionFailedSourceFailed() {
3041 +        for (boolean createIncomplete : new boolean[] { true, false })
3042          for (ExecutionMode m : ExecutionMode.values())
3043 <        for (Integer v1 : new Integer[] { 1, null }) {
3044 <
3043 >        for (Integer v1 : new Integer[] { 1, null })
3044 >    {
3045 >        final AtomicInteger a = new AtomicInteger(0);
3046          final CFException ex1 = new CFException();
3047          final CFException ex2 = new CFException();
3048          final CompletableFuture<Integer> f = new CompletableFuture<>();
3049 +
3050 +        if (!createIncomplete) f.completeExceptionally(ex1);
3051          final CompletableFuture<Integer> g = m.whenComplete
3052              (f,
3053               (Integer x, Throwable t) -> {
3054                  threadAssertSame(t, ex1);
3055                  threadAssertNull(x);
3056 +                a.getAndIncrement();
3057                  throw ex2;
3058              });
3059 <        f.completeExceptionally(ex1);
3059 >        if (createIncomplete) f.completeExceptionally(ex1);
3060 >
3061          checkCompletedWithWrappedCFException(f, ex1);
3062          checkCompletedWithWrappedCFException(g, ex1);
3063 <        }
3064 <    }
3563 <
3564 <    /**
3565 <     * handleAsync action completes normally with function value on
3566 <     * either normal or exceptional completion of source
3567 <     */
3568 <    public void testHandleAsync() {
3569 <        CompletableFuture<Integer> f, g;
3570 <        IntegerHandler r;
3571 <
3572 <        f = new CompletableFuture<>();
3573 <        g = f.handleAsync(r = new IntegerHandler());
3574 <        assertFalse(r.ran);
3575 <        f.completeExceptionally(new CFException());
3576 <        checkCompletedWithWrappedCFException(f);
3577 <        checkCompletedNormally(g, three);
3578 <        assertTrue(r.ran);
3579 <
3580 <        f = new CompletableFuture<>();
3581 <        g = f.handleAsync(r = new IntegerHandler());
3582 <        assertFalse(r.ran);
3583 <        f.completeExceptionally(new CFException());
3584 <        checkCompletedWithWrappedCFException(f);
3585 <        checkCompletedNormally(g, three);
3586 <        assertTrue(r.ran);
3587 <
3588 <        f = new CompletableFuture<>();
3589 <        g = f.handleAsync(r = new IntegerHandler());
3590 <        assertFalse(r.ran);
3591 <        f.complete(one);
3592 <        checkCompletedNormally(f, one);
3593 <        checkCompletedNormally(g, two);
3594 <        assertTrue(r.ran);
3595 <
3596 <        f = new CompletableFuture<>();
3597 <        g = f.handleAsync(r = new IntegerHandler());
3598 <        assertFalse(r.ran);
3599 <        f.complete(one);
3600 <        checkCompletedNormally(f, one);
3601 <        checkCompletedNormally(g, two);
3602 <        assertTrue(r.ran);
3603 <    }
3604 <
3605 <    /**
3606 <     * handleAsync action with Executor completes normally with
3607 <     * function value on either normal or exceptional completion of
3608 <     * source
3609 <     */
3610 <    public void testHandleAsync2() {
3611 <        CompletableFuture<Integer> f, g;
3612 <        ThreadExecutor exec = new ThreadExecutor();
3613 <        IntegerHandler r;
3614 <
3615 <        f = new CompletableFuture<>();
3616 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3617 <        assertFalse(r.ran);
3618 <        f.completeExceptionally(new CFException());
3619 <        checkCompletedWithWrappedCFException(f);
3620 <        checkCompletedNormally(g, three);
3621 <        assertTrue(r.ran);
3622 <
3623 <        f = new CompletableFuture<>();
3624 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3625 <        assertFalse(r.ran);
3626 <        f.completeExceptionally(new CFException());
3627 <        checkCompletedWithWrappedCFException(f);
3628 <        checkCompletedNormally(g, three);
3629 <        assertTrue(r.ran);
3630 <
3631 <        f = new CompletableFuture<>();
3632 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3633 <        assertFalse(r.ran);
3634 <        f.complete(one);
3635 <        checkCompletedNormally(f, one);
3636 <        checkCompletedNormally(g, two);
3637 <        assertTrue(r.ran);
3638 <
3639 <        f = new CompletableFuture<>();
3640 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3641 <        assertFalse(r.ran);
3642 <        f.complete(one);
3643 <        checkCompletedNormally(f, one);
3644 <        checkCompletedNormally(g, two);
3645 <        assertTrue(r.ran);
3646 <    }
3063 >        assertEquals(1, a.get());
3064 >    }}
3065  
3066   }

Diff Legend

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