ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java
(Generate patch)

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines