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.38 by jsr166, Sun Jun 1 23:51:44 2014 UTC vs.
Revision 1.62 by jsr166, Fri Jun 6 01:19:22 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;
342 <        public boolean ran() { return invocationCount == 1; }
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;
375 <        public boolean ran() { return invocationCount == 1; }
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.
386 <        public boolean ran() { return invocationCount == 1; }
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.
404 <        public boolean ran() { return invocationCount == 1; }
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 <        boolean ran;
412 <        public void run() { ran = true; }
410 >
411 >    class Noop extends CheckedAction implements Runnable {
412 >        Noop(ExecutionMode m) { super(m); }
413 >        public void run() {
414 >            invoked();
415 >        }
416      }
417  
418 <    static final class FailingSupplier implements Supplier<Integer> {
419 <        boolean ran;
420 <        public Integer get() { ran = true; throw new CFException(); }
418 >    class FailingSupplier extends CheckedAction implements Supplier<Integer>
419 >    {
420 >        FailingSupplier(ExecutionMode m) { super(m); }
421 >        public Integer get() {
422 >            invoked();
423 >            throw new CFException();
424 >        }
425      }
426 <    static final class FailingConsumer implements Consumer<Integer> {
427 <        boolean ran;
428 <        public void accept(Integer x) { ran = true; throw new CFException(); }
426 >
427 >    class FailingConsumer extends CheckedAction implements Consumer<Integer> {
428 >        FailingConsumer(ExecutionMode m) { super(m); }
429 >        public void accept(Integer x) {
430 >            invoked();
431 >            throw new CFException();
432 >        }
433      }
434 <    static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
435 <        boolean ran;
436 <        public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
434 >
435 >    class FailingBiConsumer extends CheckedAction
436 >        implements BiConsumer<Integer, Integer>
437 >    {
438 >        FailingBiConsumer(ExecutionMode m) { super(m); }
439 >        public void accept(Integer x, Integer y) {
440 >            invoked();
441 >            throw new CFException();
442 >        }
443      }
444 <    static final class FailingFunction implements Function<Integer, Integer> {
445 <        boolean ran;
446 <        public Integer apply(Integer x) { ran = true; throw new CFException(); }
444 >
445 >    class FailingFunction extends CheckedAction
446 >        implements Function<Integer, Integer>
447 >    {
448 >        FailingFunction(ExecutionMode m) { super(m); }
449 >        public Integer apply(Integer x) {
450 >            invoked();
451 >            throw new CFException();
452 >        }
453      }
454 <    static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
455 <        boolean ran;
456 <        public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
454 >
455 >    class FailingBiFunction extends CheckedAction
456 >        implements BiFunction<Integer, Integer, Integer>
457 >    {
458 >        FailingBiFunction(ExecutionMode m) { super(m); }
459 >        public Integer apply(Integer x, Integer y) {
460 >            invoked();
461 >            throw new CFException();
462 >        }
463      }
464 <    static final class FailingNoop implements Runnable {
465 <        boolean ran;
466 <        public void run() { ran = true; throw new CFException(); }
464 >
465 >    class FailingRunnable extends CheckedAction implements Runnable {
466 >        FailingRunnable(ExecutionMode m) { super(m); }
467 >        public void run() {
468 >            invoked();
469 >            throw new CFException();
470 >        }
471      }
472  
473 <    static final class CompletableFutureInc
474 <        implements Function<Integer, CompletableFuture<Integer>> {
475 <        boolean ran;
473 >
474 >    class CompletableFutureInc extends CheckedAction
475 >        implements Function<Integer, CompletableFuture<Integer>>
476 >    {
477 >        CompletableFutureInc(ExecutionMode m) { super(m); }
478          public CompletableFuture<Integer> apply(Integer x) {
479 <            ran = true;
479 >            invoked();
480              CompletableFuture<Integer> f = new CompletableFuture<>();
481 <            f.complete(Integer.valueOf(x.intValue() + 1));
481 >            f.complete(inc(x));
482              return f;
483          }
484      }
485  
486 <    static final class FailingCompletableFutureFunction
487 <        implements Function<Integer, CompletableFuture<Integer>> {
488 <        boolean ran;
486 >    class FailingCompletableFutureFunction extends CheckedAction
487 >        implements Function<Integer, CompletableFuture<Integer>>
488 >    {
489 >        FailingCompletableFutureFunction(ExecutionMode m) { super(m); }
490          public CompletableFuture<Integer> apply(Integer x) {
491 <            ran = true; throw new CFException();
491 >            invoked();
492 >            throw new CFException();
493          }
494      }
495  
496      // Used for explicit executor tests
497      static final class ThreadExecutor implements Executor {
498 <        AtomicInteger count = new AtomicInteger(0);
498 >        final AtomicInteger count = new AtomicInteger(0);
499 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
500 >        static boolean startedCurrentThread() {
501 >            return Thread.currentThread().getThreadGroup() == tg;
502 >        }
503  
504          public void execute(Runnable r) {
505              count.getAndIncrement();
506 <            new Thread(r).start();
433 <        }
434 <    }
435 <
436 <    static final class ExceptionToInteger implements Function<Throwable, Integer> {
437 <        public Integer apply(Throwable x) { return Integer.valueOf(3); }
438 <    }
439 <
440 <    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
441 <        boolean ran;
442 <        public Integer apply(Integer x, Throwable t) {
443 <            ran = true;
444 <            return (t == null) ? two : three;
506 >            new Thread(tg, r).start();
507          }
508      }
509  
510      /**
511       * Permits the testing of parallel code for the 3 different
512 <     * execution modes without repeating all the testing code.
512 >     * execution modes without copy/pasting all the test methods.
513       */
514      enum ExecutionMode {
515          DEFAULT {
516 +            public void checkExecutionMode() {
517 +                assertFalse(ThreadExecutor.startedCurrentThread());
518 +                assertNull(ForkJoinTask.getPool());
519 +            }
520 +            public CompletableFuture<Void> runAsync(Runnable a) {
521 +                throw new UnsupportedOperationException();
522 +            }
523 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
524 +                throw new UnsupportedOperationException();
525 +            }
526 +            public <T> CompletableFuture<Void> thenRun
527 +                (CompletableFuture<T> f, Runnable a) {
528 +                return f.thenRun(a);
529 +            }
530 +            public <T> CompletableFuture<Void> thenAccept
531 +                (CompletableFuture<T> f, Consumer<? super T> a) {
532 +                return f.thenAccept(a);
533 +            }
534 +            public <T,U> CompletableFuture<U> thenApply
535 +                (CompletableFuture<T> f, Function<? super T,U> a) {
536 +                return f.thenApply(a);
537 +            }
538 +            public <T,U> CompletableFuture<U> thenCompose
539 +                (CompletableFuture<T> f,
540 +                 Function<? super T,? extends CompletionStage<U>> a) {
541 +                return f.thenCompose(a);
542 +            }
543 +            public <T,U> CompletableFuture<U> handle
544 +                (CompletableFuture<T> f,
545 +                 BiFunction<? super T,Throwable,? extends U> a) {
546 +                return f.handle(a);
547 +            }
548 +            public <T> CompletableFuture<T> whenComplete
549 +                (CompletableFuture<T> f,
550 +                 BiConsumer<? super T,? super Throwable> a) {
551 +                return f.whenComplete(a);
552 +            }
553              public <T,U> CompletableFuture<Void> runAfterBoth
554                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
555                  return f.runAfterBoth(g, a);
# Line 467 | Line 566 | public class CompletableFutureTest exten
566                   BiFunction<? super T,? super U,? extends V> a) {
567                  return f.thenCombine(g, a);
568              }
569 <            public <T,U> CompletableFuture<U> applyToEither
569 >            public <T> CompletableFuture<Void> runAfterEither
570                  (CompletableFuture<T> f,
571 <                 CompletionStage<? extends T> g,
572 <                 Function<? super T,U> a) {
573 <                return f.applyToEither(g, a);
571 >                 CompletionStage<?> g,
572 >                 java.lang.Runnable a) {
573 >                return f.runAfterEither(g, a);
574              }
575              public <T> CompletableFuture<Void> acceptEither
576                  (CompletableFuture<T> f,
# Line 479 | Line 578 | public class CompletableFutureTest exten
578                   Consumer<? super T> a) {
579                  return f.acceptEither(g, a);
580              }
581 <            public <T> CompletableFuture<Void> runAfterEither
581 >            public <T,U> CompletableFuture<U> applyToEither
582                  (CompletableFuture<T> f,
583 <                 CompletionStage<?> g,
584 <                 java.lang.Runnable a) {
585 <                return f.runAfterEither(g, a);
583 >                 CompletionStage<? extends T> g,
584 >                 Function<? super T,U> a) {
585 >                return f.applyToEither(g, a);
586 >            }
587 >        },
588 >
589 >        ASYNC {
590 >            public void checkExecutionMode() {
591 >                assertSame(ForkJoinPool.commonPool(),
592 >                           ForkJoinTask.getPool());
593 >            }
594 >            public CompletableFuture<Void> runAsync(Runnable a) {
595 >                return CompletableFuture.runAsync(a);
596 >            }
597 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
598 >                return CompletableFuture.supplyAsync(a);
599 >            }
600 >            public <T> CompletableFuture<Void> thenRun
601 >                (CompletableFuture<T> f, Runnable a) {
602 >                return f.thenRunAsync(a);
603 >            }
604 >            public <T> CompletableFuture<Void> thenAccept
605 >                (CompletableFuture<T> f, Consumer<? super T> a) {
606 >                return f.thenAcceptAsync(a);
607 >            }
608 >            public <T,U> CompletableFuture<U> thenApply
609 >                (CompletableFuture<T> f, Function<? super T,U> a) {
610 >                return f.thenApplyAsync(a);
611              }
612              public <T,U> CompletableFuture<U> thenCompose
613                  (CompletableFuture<T> f,
614                   Function<? super T,? extends CompletionStage<U>> a) {
615 <                return f.thenCompose(a);
615 >                return f.thenComposeAsync(a);
616 >            }
617 >            public <T,U> CompletableFuture<U> handle
618 >                (CompletableFuture<T> f,
619 >                 BiFunction<? super T,Throwable,? extends U> a) {
620 >                return f.handleAsync(a);
621              }
622              public <T> CompletableFuture<T> whenComplete
623                  (CompletableFuture<T> f,
624                   BiConsumer<? super T,? super Throwable> a) {
625 <                return f.whenComplete(a);
625 >                return f.whenCompleteAsync(a);
626              }
498        },
499
500 //             /** Experimental way to do more testing */
501 //         REVERSE_DEFAULT {
502 //             public <T,U> CompletableFuture<Void> runAfterBoth
503 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
504 //                 return g.runAfterBoth(f, a);
505 //             }
506 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
507 //                 (CompletableFuture<T> f,
508 //                  CompletionStage<? extends U> g,
509 //                  BiConsumer<? super T,? super U> a) {
510 //                 return DEFAULT.thenAcceptBoth(f, g, a);
511 //             }
512 //         },
513
514        DEFAULT_ASYNC {
627              public <T,U> CompletableFuture<Void> runAfterBoth
628                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
629                  return f.runAfterBothAsync(g, a);
# Line 528 | Line 640 | public class CompletableFutureTest exten
640                   BiFunction<? super T,? super U,? extends V> a) {
641                  return f.thenCombineAsync(g, a);
642              }
643 <            public <T,U> CompletableFuture<U> applyToEither
643 >            public <T> CompletableFuture<Void> runAfterEither
644                  (CompletableFuture<T> f,
645 <                 CompletionStage<? extends T> g,
646 <                 Function<? super T,U> a) {
647 <                return f.applyToEitherAsync(g, a);
645 >                 CompletionStage<?> g,
646 >                 java.lang.Runnable a) {
647 >                return f.runAfterEitherAsync(g, a);
648              }
649              public <T> CompletableFuture<Void> acceptEither
650                  (CompletableFuture<T> f,
# Line 540 | Line 652 | public class CompletableFutureTest exten
652                   Consumer<? super T> a) {
653                  return f.acceptEitherAsync(g, a);
654              }
655 <            public <T> CompletableFuture<Void> runAfterEither
655 >            public <T,U> CompletableFuture<U> applyToEither
656                  (CompletableFuture<T> f,
657 <                 CompletionStage<?> g,
658 <                 java.lang.Runnable a) {
659 <                return f.runAfterEitherAsync(g, a);
657 >                 CompletionStage<? extends T> g,
658 >                 Function<? super T,U> a) {
659 >                return f.applyToEitherAsync(g, a);
660 >            }
661 >        },
662 >
663 >        EXECUTOR {
664 >            public void checkExecutionMode() {
665 >                assertTrue(ThreadExecutor.startedCurrentThread());
666 >            }
667 >            public CompletableFuture<Void> runAsync(Runnable a) {
668 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
669 >            }
670 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
671 >                return CompletableFuture.supplyAsync(a, new ThreadExecutor());
672 >            }
673 >            public <T> CompletableFuture<Void> thenRun
674 >                (CompletableFuture<T> f, Runnable a) {
675 >                return f.thenRunAsync(a, new ThreadExecutor());
676 >            }
677 >            public <T> CompletableFuture<Void> thenAccept
678 >                (CompletableFuture<T> f, Consumer<? super T> a) {
679 >                return f.thenAcceptAsync(a, new ThreadExecutor());
680 >            }
681 >            public <T,U> CompletableFuture<U> thenApply
682 >                (CompletableFuture<T> f, Function<? super T,U> a) {
683 >                return f.thenApplyAsync(a, new ThreadExecutor());
684              }
685              public <T,U> CompletableFuture<U> thenCompose
686                  (CompletableFuture<T> f,
687                   Function<? super T,? extends CompletionStage<U>> a) {
688 <                return f.thenComposeAsync(a);
688 >                return f.thenComposeAsync(a, new ThreadExecutor());
689 >            }
690 >            public <T,U> CompletableFuture<U> handle
691 >                (CompletableFuture<T> f,
692 >                 BiFunction<? super T,Throwable,? extends U> a) {
693 >                return f.handleAsync(a, new ThreadExecutor());
694              }
695              public <T> CompletableFuture<T> whenComplete
696                  (CompletableFuture<T> f,
697                   BiConsumer<? super T,? super Throwable> a) {
698 <                return f.whenCompleteAsync(a);
698 >                return f.whenCompleteAsync(a, new ThreadExecutor());
699              }
559        },
560
561 //         REVERSE_DEFAULT_ASYNC {
562 //             public <T,U> CompletableFuture<Void> runAfterBoth
563 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
564 //                 return f.runAfterBothAsync(g, a);
565 //             }
566 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
567 //                 (CompletableFuture<T> f,
568 //                  CompletionStage<? extends U> g,
569 //                  BiConsumer<? super T,? super U> a) {
570 //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
571 //             }
572 //         },
573
574        EXECUTOR {
700              public <T,U> CompletableFuture<Void> runAfterBoth
701                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
702                  return f.runAfterBothAsync(g, a, new ThreadExecutor());
# Line 588 | Line 713 | public class CompletableFutureTest exten
713                   BiFunction<? super T,? super U,? extends V> a) {
714                  return f.thenCombineAsync(g, a, new ThreadExecutor());
715              }
591            public <T,U> CompletableFuture<U> applyToEither
592                (CompletableFuture<T> f,
593                 CompletionStage<? extends T> g,
594                 Function<? super T,U> a) {
595                return f.applyToEitherAsync(g, a, new ThreadExecutor());
596            }
597            public <T> CompletableFuture<Void> acceptEither
598                (CompletableFuture<T> f,
599                 CompletionStage<? extends T> g,
600                 Consumer<? super T> a) {
601                return f.acceptEitherAsync(g, a, new ThreadExecutor());
602            }
716              public <T> CompletableFuture<Void> runAfterEither
717                  (CompletableFuture<T> f,
718                   CompletionStage<?> g,
719                   java.lang.Runnable a) {
720                  return f.runAfterEitherAsync(g, a, new ThreadExecutor());
721              }
722 <            public <T,U> CompletableFuture<U> thenCompose
722 >            public <T> CompletableFuture<Void> acceptEither
723                  (CompletableFuture<T> f,
724 <                 Function<? super T,? extends CompletionStage<U>> a) {
725 <                return f.thenComposeAsync(a, new ThreadExecutor());
724 >                 CompletionStage<? extends T> g,
725 >                 Consumer<? super T> a) {
726 >                return f.acceptEitherAsync(g, a, new ThreadExecutor());
727              }
728 <            public <T> CompletableFuture<T> whenComplete
728 >            public <T,U> CompletableFuture<U> applyToEither
729                  (CompletableFuture<T> f,
730 <                 BiConsumer<? super T,? super Throwable> a) {
731 <                return f.whenCompleteAsync(a, new ThreadExecutor());
730 >                 CompletionStage<? extends T> g,
731 >                 Function<? super T,U> a) {
732 >                return f.applyToEitherAsync(g, a, new ThreadExecutor());
733              }
734          };
735  
736 +        public abstract void checkExecutionMode();
737 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
738 +        public abstract <U> CompletableFuture<U> supplyAsync(Supplier<U> a);
739 +        public abstract <T> CompletableFuture<Void> thenRun
740 +            (CompletableFuture<T> f, Runnable a);
741 +        public abstract <T> CompletableFuture<Void> thenAccept
742 +            (CompletableFuture<T> f, Consumer<? super T> a);
743 +        public abstract <T,U> CompletableFuture<U> thenApply
744 +            (CompletableFuture<T> f, Function<? super T,U> a);
745 +        public abstract <T,U> CompletableFuture<U> thenCompose
746 +            (CompletableFuture<T> f,
747 +             Function<? super T,? extends CompletionStage<U>> a);
748 +        public abstract <T,U> CompletableFuture<U> handle
749 +            (CompletableFuture<T> f,
750 +             BiFunction<? super T,Throwable,? extends U> a);
751 +        public abstract <T> CompletableFuture<T> whenComplete
752 +            (CompletableFuture<T> f,
753 +             BiConsumer<? super T,? super Throwable> a);
754          public abstract <T,U> CompletableFuture<Void> runAfterBoth
755              (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
756          public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
# Line 628 | Line 761 | public class CompletableFutureTest exten
761              (CompletableFuture<T> f,
762               CompletionStage<? extends U> g,
763               BiFunction<? super T,? super U,? extends V> a);
631        public abstract <T,U> CompletableFuture<U> applyToEither
632            (CompletableFuture<T> f,
633             CompletionStage<? extends T> g,
634             Function<? super T,U> a);
635        public abstract <T> CompletableFuture<Void> acceptEither
636            (CompletableFuture<T> f,
637             CompletionStage<? extends T> g,
638             Consumer<? super T> a);
764          public abstract <T> CompletableFuture<Void> runAfterEither
765              (CompletableFuture<T> f,
766               CompletionStage<?> g,
767               java.lang.Runnable a);
768 <        public abstract <T,U> CompletableFuture<U> thenCompose
768 >        public abstract <T> CompletableFuture<Void> acceptEither
769              (CompletableFuture<T> f,
770 <             Function<? super T,? extends CompletionStage<U>> a);
771 <        public abstract <T> CompletableFuture<T> whenComplete
770 >             CompletionStage<? extends T> g,
771 >             Consumer<? super T> a);
772 >        public abstract <T,U> CompletableFuture<U> applyToEither
773              (CompletableFuture<T> f,
774 <             BiConsumer<? super T,? super Throwable> a);
774 >             CompletionStage<? extends T> g,
775 >             Function<? super T,U> a);
776 >    }
777  
778 +    /**
779 +     * exceptionally action is not invoked when source completes
780 +     * normally, and source result is propagated
781 +     */
782 +    public void testExceptionally_normalCompletion() {
783 +        for (boolean createIncomplete : new boolean[] { true, false })
784 +        for (Integer v1 : new Integer[] { 1, null })
785 +    {
786 +        final AtomicInteger a = new AtomicInteger(0);
787 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
788 +        if (!createIncomplete) f.complete(v1);
789 +        final CompletableFuture<Integer> g = f.exceptionally
790 +            ((Throwable t) -> {
791 +                // Should not be called
792 +                a.getAndIncrement();
793 +                throw new AssertionError();
794 +            });
795 +        if (createIncomplete) f.complete(v1);
796 +
797 +        checkCompletedNormally(g, v1);
798 +        checkCompletedNormally(f, v1);
799 +        assertEquals(0, a.get());
800 +    }}
801  
651    }
802  
803      /**
804       * exceptionally action completes with function value on source
805 <     * exception; otherwise with source value
805 >     * exception
806       */
807 <    public void testExceptionally() {
808 <        CompletableFuture<Integer> f = new CompletableFuture<>();
809 <        ExceptionToInteger r = new ExceptionToInteger();
810 <        CompletableFuture<Integer> g = f.exceptionally(r);
811 <        f.completeExceptionally(new CFException());
812 <        checkCompletedNormally(g, three);
807 >    public void testExceptionally_exceptionalCompletion() {
808 >        for (boolean createIncomplete : new boolean[] { true, false })
809 >        for (Integer v1 : new Integer[] { 1, null })
810 >    {
811 >        final AtomicInteger a = new AtomicInteger(0);
812 >        final CFException ex = new CFException();
813 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
814 >        if (!createIncomplete) f.completeExceptionally(ex);
815 >        final CompletableFuture<Integer> g = f.exceptionally
816 >            ((Throwable t) -> {
817 >                ExecutionMode.DEFAULT.checkExecutionMode();
818 >                threadAssertSame(t, ex);
819 >                a.getAndIncrement();
820 >                return v1;
821 >            });
822 >        if (createIncomplete) f.completeExceptionally(ex);
823  
824 <        f = new CompletableFuture<>();
825 <        r = new ExceptionToInteger();
826 <        g = f.exceptionally(r);
827 <        f.complete(one);
828 <        checkCompletedNormally(g, one);
829 <    }
824 >        checkCompletedNormally(g, v1);
825 >        assertEquals(1, a.get());
826 >    }}
827 >
828 >    public void testExceptionally_exceptionalCompletionActionFailed() {
829 >        for (boolean createIncomplete : new boolean[] { true, false })
830 >        for (Integer v1 : new Integer[] { 1, null })
831 >    {
832 >        final AtomicInteger a = new AtomicInteger(0);
833 >        final CFException ex1 = new CFException();
834 >        final CFException ex2 = new CFException();
835 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
836 >        if (!createIncomplete) f.completeExceptionally(ex1);
837 >        final CompletableFuture<Integer> g = f.exceptionally
838 >            ((Throwable t) -> {
839 >                ExecutionMode.DEFAULT.checkExecutionMode();
840 >                threadAssertSame(t, ex1);
841 >                a.getAndIncrement();
842 >                throw ex2;
843 >            });
844 >        if (createIncomplete) f.completeExceptionally(ex1);
845 >
846 >        checkCompletedWithWrappedCFException(g, ex2);
847 >        assertEquals(1, a.get());
848 >    }}
849  
850      /**
851 <     * handle action completes normally with function value on either
852 <     * normal or exceptional completion of source
851 >     * handle action completes normally with function value on normal
852 >     * completion of source
853       */
854 <    public void testHandle() {
855 <        CompletableFuture<Integer> f, g;
856 <        IntegerHandler r;
854 >    public void testHandle_normalCompletion() {
855 >        for (ExecutionMode m : ExecutionMode.values())
856 >        for (boolean createIncomplete : new boolean[] { true, false })
857 >        for (Integer v1 : new Integer[] { 1, null })
858 >    {
859 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
860 >        final AtomicInteger a = new AtomicInteger(0);
861 >        if (!createIncomplete) f.complete(v1);
862 >        final CompletableFuture<Integer> g = m.handle
863 >            (f,
864 >             (Integer x, Throwable t) -> {
865 >                m.checkExecutionMode();
866 >                threadAssertSame(x, v1);
867 >                threadAssertNull(t);
868 >                a.getAndIncrement();
869 >                return inc(v1);
870 >            });
871 >        if (createIncomplete) f.complete(v1);
872  
873 <        f = new CompletableFuture<>();
874 <        f.completeExceptionally(new CFException());
875 <        g = f.handle(r = new IntegerHandler());
876 <        assertTrue(r.ran);
683 <        checkCompletedNormally(g, three);
873 >        checkCompletedNormally(g, inc(v1));
874 >        checkCompletedNormally(f, v1);
875 >        assertEquals(1, a.get());
876 >    }}
877  
878 <        f = new CompletableFuture<>();
879 <        g = f.handle(r = new IntegerHandler());
880 <        assertFalse(r.ran);
881 <        f.completeExceptionally(new CFException());
882 <        checkCompletedNormally(g, three);
883 <        assertTrue(r.ran);
878 >    /**
879 >     * handle action completes normally with function value on
880 >     * exceptional completion of source
881 >     */
882 >    public void testHandle_exceptionalCompletion() {
883 >        for (ExecutionMode m : ExecutionMode.values())
884 >        for (boolean createIncomplete : new boolean[] { true, false })
885 >        for (Integer v1 : new Integer[] { 1, null })
886 >    {
887 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
888 >        final AtomicInteger a = new AtomicInteger(0);
889 >        final CFException ex = new CFException();
890 >        if (!createIncomplete) f.completeExceptionally(ex);
891 >        final CompletableFuture<Integer> g = m.handle
892 >            (f,
893 >             (Integer x, Throwable t) -> {
894 >                m.checkExecutionMode();
895 >                threadAssertNull(x);
896 >                threadAssertSame(t, ex);
897 >                a.getAndIncrement();
898 >                return v1;
899 >            });
900 >        if (createIncomplete) f.completeExceptionally(ex);
901  
902 <        f = new CompletableFuture<>();
903 <        f.complete(one);
904 <        g = f.handle(r = new IntegerHandler());
905 <        assertTrue(r.ran);
696 <        checkCompletedNormally(g, two);
902 >        checkCompletedNormally(g, v1);
903 >        checkCompletedWithWrappedCFException(f, ex);
904 >        assertEquals(1, a.get());
905 >    }}
906  
907 <        f = new CompletableFuture<>();
908 <        g = f.handle(r = new IntegerHandler());
909 <        assertFalse(r.ran);
910 <        f.complete(one);
911 <        assertTrue(r.ran);
912 <        checkCompletedNormally(g, two);
913 <    }
907 >    /**
908 >     * handle action completes normally with function value on
909 >     * cancelled source
910 >     */
911 >    public void testHandle_sourceCancelled() {
912 >        for (ExecutionMode m : ExecutionMode.values())
913 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
914 >        for (boolean createIncomplete : new boolean[] { true, false })
915 >        for (Integer v1 : new Integer[] { 1, null })
916 >    {
917 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
918 >        final AtomicInteger a = new AtomicInteger(0);
919 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
920 >        final CompletableFuture<Integer> g = m.handle
921 >            (f,
922 >             (Integer x, Throwable t) -> {
923 >                m.checkExecutionMode();
924 >                threadAssertNull(x);
925 >                threadAssertTrue(t instanceof CancellationException);
926 >                a.getAndIncrement();
927 >                return v1;
928 >            });
929 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
930 >
931 >        checkCompletedNormally(g, v1);
932 >        checkCancelled(f);
933 >        assertEquals(1, a.get());
934 >    }}
935  
936      /**
937 <     * runAsync completes after running Runnable
937 >     * handle result completes exceptionally if action does
938       */
939 <    public void testRunAsync() {
940 <        Noop r = new Noop();
941 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
942 <        assertNull(f.join());
943 <        assertTrue(r.ran);
944 <        checkCompletedNormally(f, null);
945 <    }
939 >    public void testHandle_sourceFailedActionFailed() {
940 >        for (ExecutionMode m : ExecutionMode.values())
941 >        for (boolean createIncomplete : new boolean[] { true, false })
942 >    {
943 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
944 >        final AtomicInteger a = new AtomicInteger(0);
945 >        final CFException ex1 = new CFException();
946 >        final CFException ex2 = new CFException();
947 >        if (!createIncomplete) f.completeExceptionally(ex1);
948 >        final CompletableFuture<Integer> g = m.handle
949 >            (f,
950 >             (Integer x, Throwable t) -> {
951 >                m.checkExecutionMode();
952 >                threadAssertNull(x);
953 >                threadAssertSame(ex1, t);
954 >                a.getAndIncrement();
955 >                throw ex2;
956 >            });
957 >        if (createIncomplete) f.completeExceptionally(ex1);
958 >
959 >        checkCompletedWithWrappedCFException(g, ex2);
960 >        checkCompletedWithWrappedCFException(f, ex1);
961 >        assertEquals(1, a.get());
962 >    }}
963 >
964 >    public void testHandle_sourceCompletedNormallyActionFailed() {
965 >        for (ExecutionMode m : ExecutionMode.values())
966 >        for (boolean createIncomplete : new boolean[] { true, false })
967 >        for (Integer v1 : new Integer[] { 1, null })
968 >    {
969 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
970 >        final AtomicInteger a = new AtomicInteger(0);
971 >        final CFException ex = new CFException();
972 >        if (!createIncomplete) f.complete(v1);
973 >        final CompletableFuture<Integer> g = m.handle
974 >            (f,
975 >             (Integer x, Throwable t) -> {
976 >                m.checkExecutionMode();
977 >                threadAssertSame(x, v1);
978 >                threadAssertNull(t);
979 >                a.getAndIncrement();
980 >                throw ex;
981 >            });
982 >        if (createIncomplete) f.complete(v1);
983 >
984 >        checkCompletedWithWrappedCFException(g, ex);
985 >        checkCompletedNormally(f, v1);
986 >        assertEquals(1, a.get());
987 >    }}
988  
989      /**
990 <     * runAsync with executor completes after running Runnable
990 >     * runAsync completes after running Runnable
991       */
992 <    public void testRunAsync2() {
993 <        Noop r = new Noop();
994 <        ThreadExecutor exec = new ThreadExecutor();
995 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
992 >    public void testRunAsync_normalCompletion() {
993 >        ExecutionMode[] executionModes = {
994 >            ExecutionMode.ASYNC,
995 >            ExecutionMode.EXECUTOR,
996 >        };
997 >        for (ExecutionMode m : executionModes)
998 >    {
999 >        final Noop r = new Noop(m);
1000 >        final CompletableFuture<Void> f = m.runAsync(r);
1001          assertNull(f.join());
725        assertTrue(r.ran);
1002          checkCompletedNormally(f, null);
1003 <        assertEquals(1, exec.count.get());
1004 <    }
1003 >        r.assertInvoked();
1004 >    }}
1005  
1006      /**
1007       * failing runAsync completes exceptionally after running Runnable
1008       */
1009 <    public void testRunAsync3() {
1010 <        FailingNoop r = new FailingNoop();
1011 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
1009 >    public void testRunAsync_exceptionalCompletion() {
1010 >        ExecutionMode[] executionModes = {
1011 >            ExecutionMode.ASYNC,
1012 >            ExecutionMode.EXECUTOR,
1013 >        };
1014 >        for (ExecutionMode m : executionModes)
1015 >    {
1016 >        final FailingRunnable r = new FailingRunnable(m);
1017 >        final CompletableFuture<Void> f = m.runAsync(r);
1018          checkCompletedWithWrappedCFException(f);
1019 <        assertTrue(r.ran);
1020 <    }
1019 >        r.assertInvoked();
1020 >    }}
1021  
1022      /**
1023       * supplyAsync completes with result of supplier
1024       */
1025 <    public void testSupplyAsync() {
1026 <        CompletableFuture<Integer> f;
1027 <        f = CompletableFuture.supplyAsync(supplyOne);
1028 <        assertEquals(f.join(), one);
1029 <        checkCompletedNormally(f, one);
1030 <    }
1031 <
1032 <    /**
1033 <     * supplyAsync with executor completes with result of supplier
1034 <     */
1035 <    public void testSupplyAsync2() {
1036 <        CompletableFuture<Integer> f;
1037 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
1038 <        assertEquals(f.join(), one);
757 <        checkCompletedNormally(f, one);
758 <    }
1025 >    public void testSupplyAsync_normalCompletion() {
1026 >        ExecutionMode[] executionModes = {
1027 >            ExecutionMode.ASYNC,
1028 >            ExecutionMode.EXECUTOR,
1029 >        };
1030 >        for (ExecutionMode m : executionModes)
1031 >        for (Integer v1 : new Integer[] { 1, null })
1032 >    {
1033 >        final IntegerSupplier r = new IntegerSupplier(m, v1);
1034 >        final CompletableFuture<Integer> f = m.supplyAsync(r);
1035 >        assertSame(v1, f.join());
1036 >        checkCompletedNormally(f, v1);
1037 >        r.assertInvoked();
1038 >    }}
1039  
1040      /**
1041       * Failing supplyAsync completes exceptionally
1042       */
1043 <    public void testSupplyAsync3() {
1044 <        FailingSupplier r = new FailingSupplier();
1045 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1043 >    public void testSupplyAsync_exceptionalCompletion() {
1044 >        ExecutionMode[] executionModes = {
1045 >            ExecutionMode.ASYNC,
1046 >            ExecutionMode.EXECUTOR,
1047 >        };
1048 >        for (ExecutionMode m : executionModes)
1049 >    {
1050 >        FailingSupplier r = new FailingSupplier(m);
1051 >        CompletableFuture<Integer> f = m.supplyAsync(r);
1052          checkCompletedWithWrappedCFException(f);
1053 <        assertTrue(r.ran);
1054 <    }
1053 >        r.assertInvoked();
1054 >    }}
1055  
1056      // seq completion methods
1057  
1058      /**
1059       * thenRun result completes normally after normal completion of source
1060       */
1061 <    public void testThenRun() {
1062 <        CompletableFuture<Integer> f;
1063 <        CompletableFuture<Void> g;
1064 <        Noop r;
1065 <
1066 <        f = new CompletableFuture<>();
1067 <        g = f.thenRun(r = new Noop());
1068 <        f.complete(null);
1069 <        checkCompletedNormally(g, null);
1070 <        assertTrue(r.ran);
1061 >    public void testThenRun_normalCompletion() {
1062 >        for (ExecutionMode m : ExecutionMode.values())
1063 >        for (boolean createIncomplete : new boolean[] { true, false })
1064 >        for (Integer v1 : new Integer[] { 1, null })
1065 >    {
1066 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1067 >        final Noop r = new Noop(m);
1068 >        if (!createIncomplete) f.complete(v1);
1069 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1070 >        if (createIncomplete) {
1071 >            checkIncomplete(g);
1072 >            f.complete(v1);
1073 >        }
1074  
786        f = new CompletableFuture<>();
787        f.complete(null);
788        g = f.thenRun(r = new Noop());
1075          checkCompletedNormally(g, null);
1076 <        assertTrue(r.ran);
1077 <    }
1076 >        checkCompletedNormally(f, v1);
1077 >        r.assertInvoked();
1078 >    }}
1079  
1080      /**
1081       * thenRun result completes exceptionally after exceptional
1082       * completion of source
1083       */
1084 <    public void testThenRun2() {
1085 <        CompletableFuture<Integer> f;
1086 <        CompletableFuture<Void> g;
1087 <        Noop r;
1088 <
1089 <        f = new CompletableFuture<>();
1090 <        g = f.thenRun(r = new Noop());
1091 <        f.completeExceptionally(new CFException());
1092 <        checkCompletedWithWrappedCFException(g);
1093 <        assertFalse(r.ran);
1084 >    public void testThenRun_exceptionalCompletion() {
1085 >        for (ExecutionMode m : ExecutionMode.values())
1086 >        for (boolean createIncomplete : new boolean[] { true, false })
1087 >    {
1088 >        final CFException ex = new CFException();
1089 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1090 >        final Noop r = new Noop(m);
1091 >        if (!createIncomplete) f.completeExceptionally(ex);
1092 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1093 >        if (createIncomplete) {
1094 >            checkIncomplete(g);
1095 >            f.completeExceptionally(ex);
1096 >        }
1097  
1098 <        f = new CompletableFuture<>();
1099 <        f.completeExceptionally(new CFException());
1100 <        g = f.thenRun(r = new Noop());
1101 <        checkCompletedWithWrappedCFException(g);
812 <        assertFalse(r.ran);
813 <    }
1098 >        checkCompletedWithWrappedCFException(g, ex);
1099 >        checkCompletedWithWrappedCFException(f, ex);
1100 >        r.assertNotInvoked();
1101 >    }}
1102  
1103      /**
1104 <     * thenRun result completes exceptionally if action does
1104 >     * thenRun result completes exceptionally if source cancelled
1105       */
1106 <    public void testThenRun3() {
1107 <        CompletableFuture<Integer> f;
1108 <        CompletableFuture<Void> g;
1109 <        FailingNoop r;
1110 <
1111 <        f = new CompletableFuture<>();
1112 <        g = f.thenRun(r = new FailingNoop());
1113 <        f.complete(null);
1114 <        checkCompletedWithWrappedCFException(g);
1106 >    public void testThenRun_sourceCancelled() {
1107 >        for (ExecutionMode m : ExecutionMode.values())
1108 >        for (boolean createIncomplete : new boolean[] { true, false })
1109 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1110 >    {
1111 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1112 >        final Noop r = new Noop(m);
1113 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1114 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1115 >        if (createIncomplete) {
1116 >            checkIncomplete(g);
1117 >            assertTrue(f.cancel(mayInterruptIfRunning));
1118 >        }
1119  
1120 <        f = new CompletableFuture<>();
1121 <        f.complete(null);
1122 <        g = f.thenRun(r = new FailingNoop());
1123 <        checkCompletedWithWrappedCFException(g);
832 <    }
1120 >        checkCompletedWithWrappedCancellationException(g);
1121 >        checkCancelled(f);
1122 >        r.assertNotInvoked();
1123 >    }}
1124  
1125      /**
1126 <     * thenRun result completes exceptionally if source cancelled
1126 >     * thenRun result completes exceptionally if action does
1127       */
1128 <    public void testThenRun4() {
1129 <        CompletableFuture<Integer> f;
1130 <        CompletableFuture<Void> g;
1131 <        Noop r;
1132 <
1133 <        f = new CompletableFuture<>();
1134 <        g = f.thenRun(r = new Noop());
1135 <        assertTrue(f.cancel(true));
1136 <        checkCompletedWithWrappedCancellationException(g);
1128 >    public void testThenRun_actionFailed() {
1129 >        for (ExecutionMode m : ExecutionMode.values())
1130 >        for (boolean createIncomplete : new boolean[] { true, false })
1131 >        for (Integer v1 : new Integer[] { 1, null })
1132 >    {
1133 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1134 >        final FailingRunnable r = new FailingRunnable(m);
1135 >        if (!createIncomplete) f.complete(v1);
1136 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1137 >        if (createIncomplete) {
1138 >            checkIncomplete(g);
1139 >            f.complete(v1);
1140 >        }
1141  
1142 <        f = new CompletableFuture<>();
1143 <        assertTrue(f.cancel(true));
1144 <        g = f.thenRun(r = new Noop());
850 <        checkCompletedWithWrappedCancellationException(g);
851 <    }
1142 >        checkCompletedWithWrappedCFException(g);
1143 >        checkCompletedNormally(f, v1);
1144 >    }}
1145  
1146      /**
1147       * thenApply result completes normally after normal completion of source
1148       */
1149 <    public void testThenApply() {
1150 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1151 <        CompletableFuture<Integer> g = f.thenApply(inc);
1152 <        f.complete(one);
1153 <        checkCompletedNormally(g, two);
1154 <    }
1149 >    public void testThenApply_normalCompletion() {
1150 >        for (ExecutionMode m : ExecutionMode.values())
1151 >        for (boolean createIncomplete : new boolean[] { true, false })
1152 >        for (Integer v1 : new Integer[] { 1, null })
1153 >    {
1154 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1155 >        final IncFunction r = new IncFunction(m);
1156 >        if (!createIncomplete) f.complete(v1);
1157 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1158 >        if (createIncomplete) {
1159 >            checkIncomplete(g);
1160 >            f.complete(v1);
1161 >        }
1162 >
1163 >        checkCompletedNormally(g, inc(v1));
1164 >        checkCompletedNormally(f, v1);
1165 >        r.assertInvoked();
1166 >    }}
1167  
1168      /**
1169       * thenApply result completes exceptionally after exceptional
1170       * completion of source
1171       */
1172 <    public void testThenApply2() {
1173 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1174 <        CompletableFuture<Integer> g = f.thenApply(inc);
1175 <        f.completeExceptionally(new CFException());
1176 <        checkCompletedWithWrappedCFException(g);
1177 <    }
1172 >    public void testThenApply_exceptionalCompletion() {
1173 >        for (ExecutionMode m : ExecutionMode.values())
1174 >        for (boolean createIncomplete : new boolean[] { true, false })
1175 >    {
1176 >        final CFException ex = new CFException();
1177 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1178 >        final IncFunction r = new IncFunction(m);
1179 >        if (!createIncomplete) f.completeExceptionally(ex);
1180 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1181 >        if (createIncomplete) {
1182 >            checkIncomplete(g);
1183 >            f.completeExceptionally(ex);
1184 >        }
1185  
1186 <    /**
1187 <     * thenApply result completes exceptionally if action does
1188 <     */
1189 <    public void testThenApply3() {
878 <        CompletableFuture<Integer> f = new CompletableFuture<>();
879 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
880 <        f.complete(one);
881 <        checkCompletedWithWrappedCFException(g);
882 <    }
1186 >        checkCompletedWithWrappedCFException(g, ex);
1187 >        checkCompletedWithWrappedCFException(f, ex);
1188 >        r.assertNotInvoked();
1189 >    }}
1190  
1191      /**
1192       * thenApply result completes exceptionally if source cancelled
1193       */
1194 <    public void testThenApply4() {
1195 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1196 <        CompletableFuture<Integer> g = f.thenApply(inc);
1197 <        assertTrue(f.cancel(true));
1194 >    public void testThenApply_sourceCancelled() {
1195 >        for (ExecutionMode m : ExecutionMode.values())
1196 >        for (boolean createIncomplete : new boolean[] { true, false })
1197 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1198 >    {
1199 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1200 >        final IncFunction r = new IncFunction(m);
1201 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1202 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1203 >        if (createIncomplete) {
1204 >            checkIncomplete(g);
1205 >            assertTrue(f.cancel(mayInterruptIfRunning));
1206 >        }
1207 >
1208          checkCompletedWithWrappedCancellationException(g);
1209 <    }
1209 >        checkCancelled(f);
1210 >        r.assertNotInvoked();
1211 >    }}
1212 >
1213 >    /**
1214 >     * thenApply result completes exceptionally if action does
1215 >     */
1216 >    public void testThenApply_actionFailed() {
1217 >        for (ExecutionMode m : ExecutionMode.values())
1218 >        for (boolean createIncomplete : new boolean[] { true, false })
1219 >        for (Integer v1 : new Integer[] { 1, null })
1220 >    {
1221 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1222 >        final FailingFunction r = new FailingFunction(m);
1223 >        if (!createIncomplete) f.complete(v1);
1224 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1225 >        if (createIncomplete) {
1226 >            checkIncomplete(g);
1227 >            f.complete(v1);
1228 >        }
1229 >
1230 >        checkCompletedWithWrappedCFException(g);
1231 >        checkCompletedNormally(f, v1);
1232 >    }}
1233  
1234      /**
1235       * thenAccept result completes normally after normal completion of source
1236       */
1237 <    public void testThenAccept() {
1238 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1239 <        IncAction r = new IncAction();
1240 <        CompletableFuture<Void> g = f.thenAccept(r);
1241 <        f.complete(one);
1237 >    public void testThenAccept_normalCompletion() {
1238 >        for (ExecutionMode m : ExecutionMode.values())
1239 >        for (boolean createIncomplete : new boolean[] { true, false })
1240 >        for (Integer v1 : new Integer[] { 1, null })
1241 >    {
1242 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1243 >        final IncAction r = new IncAction(m);
1244 >        if (!createIncomplete) f.complete(v1);
1245 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1246 >        if (createIncomplete) {
1247 >            checkIncomplete(g);
1248 >            f.complete(v1);
1249 >        }
1250 >
1251          checkCompletedNormally(g, null);
1252 <        assertEquals(r.value, (Integer) 2);
1253 <    }
1252 >        checkCompletedNormally(f, v1);
1253 >        r.assertInvoked();
1254 >        r.assertValue(inc(v1));
1255 >    }}
1256  
1257      /**
1258       * thenAccept result completes exceptionally after exceptional
1259       * completion of source
1260       */
1261 <    public void testThenAccept2() {
1262 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1263 <        IncAction r = new IncAction();
1264 <        CompletableFuture<Void> g = f.thenAccept(r);
1265 <        f.completeExceptionally(new CFException());
1266 <        checkCompletedWithWrappedCFException(g);
1267 <    }
1261 >    public void testThenAccept_exceptionalCompletion() {
1262 >        for (ExecutionMode m : ExecutionMode.values())
1263 >        for (boolean createIncomplete : new boolean[] { true, false })
1264 >    {
1265 >        final CFException ex = new CFException();
1266 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1267 >        final IncAction r = new IncAction(m);
1268 >        if (!createIncomplete) f.completeExceptionally(ex);
1269 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1270 >        if (createIncomplete) {
1271 >            checkIncomplete(g);
1272 >            f.completeExceptionally(ex);
1273 >        }
1274  
1275 <    /**
1276 <     * thenAccept result completes exceptionally if action does
1277 <     */
1278 <    public void testThenAccept3() {
922 <        CompletableFuture<Integer> f = new CompletableFuture<>();
923 <        FailingConsumer r = new FailingConsumer();
924 <        CompletableFuture<Void> g = f.thenAccept(r);
925 <        f.complete(one);
926 <        checkCompletedWithWrappedCFException(g);
927 <        assertTrue(r.ran);
928 <    }
1275 >        checkCompletedWithWrappedCFException(g, ex);
1276 >        checkCompletedWithWrappedCFException(f, ex);
1277 >        r.assertNotInvoked();
1278 >    }}
1279  
1280      /**
1281       * thenAccept result completes exceptionally if source cancelled
1282       */
1283 <    public void testThenAccept4() {
1284 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1285 <        IncAction r = new IncAction();
1286 <        CompletableFuture<Void> g = f.thenAccept(r);
1287 <        assertTrue(f.cancel(true));
1283 >    public void testThenAccept_sourceCancelled() {
1284 >        for (ExecutionMode m : ExecutionMode.values())
1285 >        for (boolean createIncomplete : new boolean[] { true, false })
1286 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1287 >    {
1288 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1289 >        final IncAction r = new IncAction(m);
1290 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1291 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1292 >        if (createIncomplete) {
1293 >            checkIncomplete(g);
1294 >            assertTrue(f.cancel(mayInterruptIfRunning));
1295 >        }
1296 >
1297          checkCompletedWithWrappedCancellationException(g);
1298 <    }
1298 >        checkCancelled(f);
1299 >        r.assertNotInvoked();
1300 >    }}
1301  
1302      /**
1303 <     * thenCombine result completes normally after normal completion
943 <     * of sources
1303 >     * thenAccept result completes exceptionally if action does
1304       */
1305 <    public void testThenCombine_normalCompletion1() {
1305 >    public void testThenAccept_actionFailed() {
1306          for (ExecutionMode m : ExecutionMode.values())
1307 +        for (boolean createIncomplete : new boolean[] { true, false })
1308          for (Integer v1 : new Integer[] { 1, null })
1309 <        for (Integer v2 : new Integer[] { 2, null }) {
949 <
1309 >    {
1310          final CompletableFuture<Integer> f = new CompletableFuture<>();
1311 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1312 <        final SubtractFunction r = new SubtractFunction();
1313 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1314 <
1315 <        f.complete(v1);
1316 <        checkIncomplete(h);
1317 <        assertFalse(r.ran());
958 <        g.complete(v2);
1311 >        final FailingConsumer r = new FailingConsumer(m);
1312 >        if (!createIncomplete) f.complete(v1);
1313 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1314 >        if (createIncomplete) {
1315 >            checkIncomplete(g);
1316 >            f.complete(v1);
1317 >        }
1318  
1319 <        checkCompletedNormally(h, subtract(v1, v2));
1319 >        checkCompletedWithWrappedCFException(g);
1320          checkCompletedNormally(f, v1);
1321 <        checkCompletedNormally(g, v2);
963 <        }
964 <    }
1321 >    }}
1322  
1323 <    public void testThenCombine_normalCompletion2() {
1323 >    /**
1324 >     * thenCombine result completes normally after normal completion
1325 >     * of sources
1326 >     */
1327 >    public void testThenCombine_normalCompletion() {
1328          for (ExecutionMode m : ExecutionMode.values())
1329 +        for (boolean createIncomplete : new boolean[] { true, false })
1330 +        for (boolean fFirst : new boolean[] { true, false })
1331          for (Integer v1 : new Integer[] { 1, null })
1332 <        for (Integer v2 : new Integer[] { 2, null }) {
1333 <
1332 >        for (Integer v2 : new Integer[] { 2, null })
1333 >    {
1334          final CompletableFuture<Integer> f = new CompletableFuture<>();
1335          final CompletableFuture<Integer> g = new CompletableFuture<>();
1336 <        final SubtractFunction r = new SubtractFunction();
974 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1336 >        final SubtractFunction r = new SubtractFunction(m);
1337  
1338 <        g.complete(v2);
1339 <        checkIncomplete(h);
1340 <        assertFalse(r.ran());
1341 <        f.complete(v1);
1338 >        if (fFirst) f.complete(v1); else g.complete(v2);
1339 >        if (!createIncomplete)
1340 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1341 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1342 >        if (createIncomplete) {
1343 >            checkIncomplete(h);
1344 >            r.assertNotInvoked();
1345 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1346 >        }
1347  
1348          checkCompletedNormally(h, subtract(v1, v2));
1349          checkCompletedNormally(f, v1);
1350          checkCompletedNormally(g, v2);
1351 <        }
1352 <    }
1351 >        r.assertInvoked();
1352 >    }}
1353  
1354 <    public void testThenCombine_normalCompletion3() {
1354 >    /**
1355 >     * thenCombine result completes exceptionally after exceptional
1356 >     * completion of either source
1357 >     */
1358 >    public void testThenCombine_exceptionalCompletion() {
1359          for (ExecutionMode m : ExecutionMode.values())
1360 +        for (boolean createIncomplete : new boolean[] { true, false })
1361 +        for (boolean fFirst : new boolean[] { true, false })
1362          for (Integer v1 : new Integer[] { 1, null })
1363 <        for (Integer v2 : new Integer[] { 2, null }) {
991 <
1363 >    {
1364          final CompletableFuture<Integer> f = new CompletableFuture<>();
1365          final CompletableFuture<Integer> g = new CompletableFuture<>();
1366 <        final SubtractFunction r = new SubtractFunction();
1366 >        final CFException ex = new CFException();
1367 >        final SubtractFunction r = new SubtractFunction(m);
1368  
1369 <        g.complete(v2);
1370 <        f.complete(v1);
1369 >        (fFirst ? f : g).complete(v1);
1370 >        if (!createIncomplete)
1371 >            (!fFirst ? f : g).completeExceptionally(ex);
1372          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1373 <
1374 <        checkCompletedNormally(h, subtract(v1, v2));
1375 <        checkCompletedNormally(f, v1);
1002 <        checkCompletedNormally(g, v2);
1373 >        if (createIncomplete) {
1374 >            checkIncomplete(h);
1375 >            (!fFirst ? f : g).completeExceptionally(ex);
1376          }
1004    }
1377  
1378 <    public void testThenCombine_normalCompletion4() {
1378 >        checkCompletedWithWrappedCFException(h, ex);
1379 >        r.assertNotInvoked();
1380 >        checkCompletedNormally(fFirst ? f : g, v1);
1381 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1382 >    }}
1383 >
1384 >    /**
1385 >     * thenCombine result completes exceptionally if either source cancelled
1386 >     */
1387 >    public void testThenCombine_sourceCancelled() {
1388          for (ExecutionMode m : ExecutionMode.values())
1389 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1390 +        for (boolean createIncomplete : new boolean[] { true, false })
1391 +        for (boolean fFirst : new boolean[] { true, false })
1392          for (Integer v1 : new Integer[] { 1, null })
1393 <        for (Integer v2 : new Integer[] { 2, null }) {
1010 <
1393 >    {
1394          final CompletableFuture<Integer> f = new CompletableFuture<>();
1395          final CompletableFuture<Integer> g = new CompletableFuture<>();
1396 <        final SubtractFunction r = new SubtractFunction();
1396 >        final SubtractFunction r = new SubtractFunction(m);
1397  
1398 <        f.complete(v1);
1399 <        g.complete(v2);
1398 >        (fFirst ? f : g).complete(v1);
1399 >        if (!createIncomplete)
1400 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1401          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1402 <
1403 <        checkCompletedNormally(h, subtract(v1, v2));
1404 <        checkCompletedNormally(f, v1);
1021 <        checkCompletedNormally(g, v2);
1402 >        if (createIncomplete) {
1403 >            checkIncomplete(h);
1404 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1405          }
1406 <    }
1406 >
1407 >        checkCompletedWithWrappedCancellationException(h);
1408 >        checkCancelled(!fFirst ? f : g);
1409 >        r.assertNotInvoked();
1410 >        checkCompletedNormally(fFirst ? f : g, v1);
1411 >    }}
1412  
1413      /**
1414 <     * thenCombine result completes exceptionally after exceptional
1027 <     * completion of either source
1414 >     * thenCombine result completes exceptionally if action does
1415       */
1416 <    public void testThenCombine_exceptionalCompletion1() {
1416 >    public void testThenCombine_actionFailed() {
1417          for (ExecutionMode m : ExecutionMode.values())
1418 <        for (Integer v1 : new Integer[] { 1, null }) {
1419 <
1418 >        for (boolean fFirst : new boolean[] { true, false })
1419 >        for (Integer v1 : new Integer[] { 1, null })
1420 >        for (Integer v2 : new Integer[] { 2, null })
1421 >    {
1422          final CompletableFuture<Integer> f = new CompletableFuture<>();
1423          final CompletableFuture<Integer> g = new CompletableFuture<>();
1424 <        final SubtractFunction r = new SubtractFunction();
1424 >        final FailingBiFunction r = new FailingBiFunction(m);
1425          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1037        final CFException ex = new CFException();
1038
1039        f.completeExceptionally(ex);
1040        checkIncomplete(h);
1041        g.complete(v1);
1426  
1427 <        checkCompletedWithWrappedCFException(h, ex);
1428 <        checkCompletedWithWrappedCFException(f, ex);
1429 <        assertFalse(r.ran());
1430 <        checkCompletedNormally(g, v1);
1427 >        if (fFirst) {
1428 >            f.complete(v1);
1429 >            g.complete(v2);
1430 >        } else {
1431 >            g.complete(v2);
1432 >            f.complete(v1);
1433          }
1048    }
1434  
1435 <    public void testThenCombine_exceptionalCompletion2() {
1436 <        for (ExecutionMode m : ExecutionMode.values())
1437 <        for (Integer v1 : new Integer[] { 1, null }) {
1435 >        checkCompletedWithWrappedCFException(h);
1436 >        checkCompletedNormally(f, v1);
1437 >        checkCompletedNormally(g, v2);
1438 >    }}
1439  
1440 +    /**
1441 +     * thenAcceptBoth result completes normally after normal
1442 +     * completion of sources
1443 +     */
1444 +    public void testThenAcceptBoth_normalCompletion() {
1445 +        for (ExecutionMode m : ExecutionMode.values())
1446 +        for (boolean createIncomplete : new boolean[] { true, false })
1447 +        for (boolean fFirst : new boolean[] { true, false })
1448 +        for (Integer v1 : new Integer[] { 1, null })
1449 +        for (Integer v2 : new Integer[] { 2, null })
1450 +    {
1451          final CompletableFuture<Integer> f = new CompletableFuture<>();
1452          final CompletableFuture<Integer> g = new CompletableFuture<>();
1453 <        final SubtractFunction r = new SubtractFunction();
1057 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1058 <        final CFException ex = new CFException();
1453 >        final SubtractAction r = new SubtractAction(m);
1454  
1455 <        g.completeExceptionally(ex);
1456 <        checkIncomplete(h);
1457 <        f.complete(v1);
1455 >        if (fFirst) f.complete(v1); else g.complete(v2);
1456 >        if (!createIncomplete)
1457 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1458 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1459 >        if (createIncomplete) {
1460 >            checkIncomplete(h);
1461 >            r.assertNotInvoked();
1462 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1463 >        }
1464  
1465 <        checkCompletedWithWrappedCFException(h, ex);
1466 <        checkCompletedWithWrappedCFException(g, ex);
1066 <        assertFalse(r.ran());
1465 >        checkCompletedNormally(h, null);
1466 >        r.assertValue(subtract(v1, v2));
1467          checkCompletedNormally(f, v1);
1468 <        }
1469 <    }
1468 >        checkCompletedNormally(g, v2);
1469 >    }}
1470  
1471 <    public void testThenCombine_exceptionalCompletion3() {
1471 >    /**
1472 >     * thenAcceptBoth result completes exceptionally after exceptional
1473 >     * completion of either source
1474 >     */
1475 >    public void testThenAcceptBoth_exceptionalCompletion() {
1476          for (ExecutionMode m : ExecutionMode.values())
1477 <        for (Integer v1 : new Integer[] { 1, null }) {
1478 <
1477 >        for (boolean createIncomplete : new boolean[] { true, false })
1478 >        for (boolean fFirst : new boolean[] { true, false })
1479 >        for (Integer v1 : new Integer[] { 1, null })
1480 >    {
1481          final CompletableFuture<Integer> f = new CompletableFuture<>();
1482          final CompletableFuture<Integer> g = new CompletableFuture<>();
1077        final SubtractFunction r = new SubtractFunction();
1483          final CFException ex = new CFException();
1484 +        final SubtractAction r = new SubtractAction(m);
1485  
1486 <        g.completeExceptionally(ex);
1487 <        f.complete(v1);
1488 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1486 >        (fFirst ? f : g).complete(v1);
1487 >        if (!createIncomplete)
1488 >            (!fFirst ? f : g).completeExceptionally(ex);
1489 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1490 >        if (createIncomplete) {
1491 >            checkIncomplete(h);
1492 >            (!fFirst ? f : g).completeExceptionally(ex);
1493 >        }
1494  
1495          checkCompletedWithWrappedCFException(h, ex);
1496 <        checkCompletedWithWrappedCFException(g, ex);
1497 <        assertFalse(r.ran());
1498 <        checkCompletedNormally(f, v1);
1499 <        }
1089 <    }
1496 >        r.assertNotInvoked();
1497 >        checkCompletedNormally(fFirst ? f : g, v1);
1498 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1499 >    }}
1500  
1501 <    public void testThenCombine_exceptionalCompletion4() {
1501 >    /**
1502 >     * thenAcceptBoth result completes exceptionally if either source cancelled
1503 >     */
1504 >    public void testThenAcceptBoth_sourceCancelled() {
1505          for (ExecutionMode m : ExecutionMode.values())
1506 <        for (Integer v1 : new Integer[] { 1, null }) {
1507 <
1506 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1507 >        for (boolean createIncomplete : new boolean[] { true, false })
1508 >        for (boolean fFirst : new boolean[] { true, false })
1509 >        for (Integer v1 : new Integer[] { 1, null })
1510 >    {
1511          final CompletableFuture<Integer> f = new CompletableFuture<>();
1512          final CompletableFuture<Integer> g = new CompletableFuture<>();
1513 <        final SubtractFunction r = new SubtractFunction();
1098 <        final CFException ex = new CFException();
1099 <
1100 <        f.completeExceptionally(ex);
1101 <        g.complete(v1);
1102 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1513 >        final SubtractAction r = new SubtractAction(m);
1514  
1515 <        checkCompletedWithWrappedCFException(h, ex);
1516 <        checkCompletedWithWrappedCFException(f, ex);
1517 <        assertFalse(r.ran());
1518 <        checkCompletedNormally(g, v1);
1515 >        (fFirst ? f : g).complete(v1);
1516 >        if (!createIncomplete)
1517 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1518 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1519 >        if (createIncomplete) {
1520 >            checkIncomplete(h);
1521 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1522          }
1523 <    }
1523 >
1524 >        checkCompletedWithWrappedCancellationException(h);
1525 >        checkCancelled(!fFirst ? f : g);
1526 >        r.assertNotInvoked();
1527 >        checkCompletedNormally(fFirst ? f : g, v1);
1528 >    }}
1529  
1530      /**
1531 <     * thenCombine result completes exceptionally if action does
1531 >     * thenAcceptBoth result completes exceptionally if action does
1532       */
1533 <    public void testThenCombine_actionFailed1() {
1533 >    public void testThenAcceptBoth_actionFailed() {
1534          for (ExecutionMode m : ExecutionMode.values())
1535 +        for (boolean fFirst : new boolean[] { true, false })
1536          for (Integer v1 : new Integer[] { 1, null })
1537 <        for (Integer v2 : new Integer[] { 2, null }) {
1538 <
1537 >        for (Integer v2 : new Integer[] { 2, null })
1538 >    {
1539          final CompletableFuture<Integer> f = new CompletableFuture<>();
1540          final CompletableFuture<Integer> g = new CompletableFuture<>();
1541 <        final FailingBiFunction r = new FailingBiFunction();
1542 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1541 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1542 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1543  
1544 <        f.complete(v1);
1545 <        checkIncomplete(h);
1546 <        g.complete(v2);
1544 >        if (fFirst) {
1545 >            f.complete(v1);
1546 >            g.complete(v2);
1547 >        } else {
1548 >            g.complete(v2);
1549 >            f.complete(v1);
1550 >        }
1551  
1552          checkCompletedWithWrappedCFException(h);
1553          checkCompletedNormally(f, v1);
1554          checkCompletedNormally(g, v2);
1555 <        }
1132 <    }
1555 >    }}
1556  
1557 <    public void testThenCombine_actionFailed2() {
1557 >    /**
1558 >     * runAfterBoth result completes normally after normal
1559 >     * completion of sources
1560 >     */
1561 >    public void testRunAfterBoth_normalCompletion() {
1562          for (ExecutionMode m : ExecutionMode.values())
1563 +        for (boolean createIncomplete : new boolean[] { true, false })
1564 +        for (boolean fFirst : new boolean[] { true, false })
1565          for (Integer v1 : new Integer[] { 1, null })
1566 <        for (Integer v2 : new Integer[] { 2, null }) {
1567 <
1566 >        for (Integer v2 : new Integer[] { 2, null })
1567 >    {
1568          final CompletableFuture<Integer> f = new CompletableFuture<>();
1569          final CompletableFuture<Integer> g = new CompletableFuture<>();
1570 <        final FailingBiFunction r = new FailingBiFunction();
1142 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1570 >        final Noop r = new Noop(m);
1571  
1572 <        g.complete(v2);
1573 <        checkIncomplete(h);
1574 <        f.complete(v1);
1572 >        if (fFirst) f.complete(v1); else g.complete(v2);
1573 >        if (!createIncomplete)
1574 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1575 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1576 >        if (createIncomplete) {
1577 >            checkIncomplete(h);
1578 >            r.assertNotInvoked();
1579 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1580 >        }
1581  
1582 <        checkCompletedWithWrappedCFException(h);
1582 >        checkCompletedNormally(h, null);
1583 >        r.assertInvoked();
1584          checkCompletedNormally(f, v1);
1585          checkCompletedNormally(g, v2);
1586 +    }}
1587 +
1588 +    /**
1589 +     * runAfterBoth result completes exceptionally after exceptional
1590 +     * completion of either source
1591 +     */
1592 +    public void testRunAfterBoth_exceptionalCompletion() {
1593 +        for (ExecutionMode m : ExecutionMode.values())
1594 +        for (boolean createIncomplete : new boolean[] { true, false })
1595 +        for (boolean fFirst : new boolean[] { true, false })
1596 +        for (Integer v1 : new Integer[] { 1, null })
1597 +    {
1598 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1599 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1600 +        final CFException ex = new CFException();
1601 +        final Noop r = new Noop(m);
1602 +
1603 +        (fFirst ? f : g).complete(v1);
1604 +        if (!createIncomplete)
1605 +            (!fFirst ? f : g).completeExceptionally(ex);
1606 +        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1607 +        if (createIncomplete) {
1608 +            checkIncomplete(h);
1609 +            (!fFirst ? f : g).completeExceptionally(ex);
1610          }
1611 <    }
1611 >
1612 >        checkCompletedWithWrappedCFException(h, ex);
1613 >        r.assertNotInvoked();
1614 >        checkCompletedNormally(fFirst ? f : g, v1);
1615 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1616 >    }}
1617  
1618      /**
1619 <     * thenCombine result completes exceptionally if either source cancelled
1619 >     * runAfterBoth result completes exceptionally if either source cancelled
1620       */
1621 <    public void testThenCombine_sourceCancelled1() {
1621 >    public void testRunAfterBoth_sourceCancelled() {
1622          for (ExecutionMode m : ExecutionMode.values())
1623          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1624 <        for (Integer v1 : new Integer[] { 1, null }) {
1625 <
1624 >        for (boolean createIncomplete : new boolean[] { true, false })
1625 >        for (boolean fFirst : new boolean[] { true, false })
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 SubtractFunction r = new SubtractFunction();
1165 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1630 >        final Noop r = new Noop(m);
1631  
1167        assertTrue(f.cancel(mayInterruptIfRunning));
1168        checkIncomplete(h);
1169        g.complete(v1);
1632  
1633 <        checkCompletedWithWrappedCancellationException(h);
1634 <        checkCancelled(f);
1635 <        assertFalse(r.ran());
1636 <        checkCompletedNormally(g, v1);
1633 >        (fFirst ? f : g).complete(v1);
1634 >        if (!createIncomplete)
1635 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1636 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1637 >        if (createIncomplete) {
1638 >            checkIncomplete(h);
1639 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1640          }
1176    }
1641  
1642 <    public void testThenCombine_sourceCancelled2() {
1643 <        for (ExecutionMode m : ExecutionMode.values())
1644 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1645 <        for (Integer v1 : new Integer[] { 1, null }) {
1642 >        checkCompletedWithWrappedCancellationException(h);
1643 >        checkCancelled(!fFirst ? f : g);
1644 >        r.assertNotInvoked();
1645 >        checkCompletedNormally(fFirst ? f : g, v1);
1646 >    }}
1647  
1648 +    /**
1649 +     * runAfterBoth result completes exceptionally if action does
1650 +     */
1651 +    public void testRunAfterBoth_actionFailed() {
1652 +        for (ExecutionMode m : ExecutionMode.values())
1653 +        for (boolean fFirst : new boolean[] { true, false })
1654 +        for (Integer v1 : new Integer[] { 1, null })
1655 +        for (Integer v2 : new Integer[] { 2, null })
1656 +    {
1657          final CompletableFuture<Integer> f = new CompletableFuture<>();
1658          final CompletableFuture<Integer> g = new CompletableFuture<>();
1659 <        final SubtractFunction r = new SubtractFunction();
1660 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1659 >        final FailingRunnable r1 = new FailingRunnable(m);
1660 >        final FailingRunnable r2 = new FailingRunnable(m);
1661  
1662 <        assertTrue(g.cancel(mayInterruptIfRunning));
1663 <        checkIncomplete(h);
1664 <        f.complete(v1);
1662 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1663 >        if (fFirst) {
1664 >            f.complete(v1);
1665 >            g.complete(v2);
1666 >        } else {
1667 >            g.complete(v2);
1668 >            f.complete(v1);
1669 >        }
1670 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1671  
1672 <        checkCompletedWithWrappedCancellationException(h);
1673 <        checkCancelled(g);
1194 <        assertFalse(r.ran());
1672 >        checkCompletedWithWrappedCFException(h1);
1673 >        checkCompletedWithWrappedCFException(h2);
1674          checkCompletedNormally(f, v1);
1675 <        }
1676 <    }
1675 >        checkCompletedNormally(g, v2);
1676 >    }}
1677  
1678 <    public void testThenCombine_sourceCancelled3() {
1678 >    /**
1679 >     * applyToEither result completes normally after normal completion
1680 >     * of either source
1681 >     */
1682 >    public void testApplyToEither_normalCompletion() {
1683          for (ExecutionMode m : ExecutionMode.values())
1684 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1685 <        for (Integer v1 : new Integer[] { 1, null }) {
1686 <
1684 >        for (Integer v1 : new Integer[] { 1, null })
1685 >        for (Integer v2 : new Integer[] { 2, null })
1686 >    {
1687          final CompletableFuture<Integer> f = new CompletableFuture<>();
1688          final CompletableFuture<Integer> g = new CompletableFuture<>();
1689 <        final SubtractFunction r = new SubtractFunction();
1689 >        final IncFunction[] rs = new IncFunction[6];
1690 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1691  
1692 <        assertTrue(g.cancel(mayInterruptIfRunning));
1693 <        f.complete(v1);
1694 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1692 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1693 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1694 >        checkIncomplete(h0);
1695 >        checkIncomplete(h1);
1696 >        rs[0].assertNotInvoked();
1697 >        rs[1].assertNotInvoked();
1698 >        f.complete(v1);
1699 >        checkCompletedNormally(h0, inc(v1));
1700 >        checkCompletedNormally(h1, inc(v1));
1701 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1702 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1703 >        checkCompletedNormally(h2, inc(v1));
1704 >        checkCompletedNormally(h3, inc(v1));
1705 >        g.complete(v2);
1706 >
1707 >        // unspecified behavior - both source completions available
1708 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1709 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1710 >        rs[4].assertValue(h4.join());
1711 >        rs[5].assertValue(h5.join());
1712 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
1713 >                   Objects.equals(inc(v2), h4.join()));
1714 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
1715 >                   Objects.equals(inc(v2), h5.join()));
1716  
1212        checkCompletedWithWrappedCancellationException(h);
1213        checkCancelled(g);
1214        assertFalse(r.ran());
1717          checkCompletedNormally(f, v1);
1718 +        checkCompletedNormally(g, v2);
1719 +        checkCompletedNormally(h0, inc(v1));
1720 +        checkCompletedNormally(h1, inc(v1));
1721 +        checkCompletedNormally(h2, inc(v1));
1722 +        checkCompletedNormally(h3, inc(v1));
1723 +        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
1724 +    }}
1725 +
1726 +    /**
1727 +     * applyToEither result completes exceptionally after exceptional
1728 +     * completion of either source
1729 +     */
1730 +    public void testApplyToEither_exceptionalCompletion() {
1731 +        for (ExecutionMode m : ExecutionMode.values())
1732 +        for (Integer v1 : new Integer[] { 1, null })
1733 +    {
1734 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1735 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1736 +        final CFException ex = new CFException();
1737 +        final IncFunction[] rs = new IncFunction[6];
1738 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1739 +
1740 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1741 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1742 +        checkIncomplete(h0);
1743 +        checkIncomplete(h1);
1744 +        rs[0].assertNotInvoked();
1745 +        rs[1].assertNotInvoked();
1746 +        f.completeExceptionally(ex);
1747 +        checkCompletedWithWrappedCFException(h0, ex);
1748 +        checkCompletedWithWrappedCFException(h1, ex);
1749 +        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1750 +        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1751 +        checkCompletedWithWrappedCFException(h2, ex);
1752 +        checkCompletedWithWrappedCFException(h3, ex);
1753 +        g.complete(v1);
1754 +
1755 +        // unspecified behavior - both source completions available
1756 +        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1757 +        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1758 +        try {
1759 +            assertEquals(inc(v1), h4.join());
1760 +            rs[4].assertInvoked();
1761 +        } catch (CompletionException ok) {
1762 +            checkCompletedWithWrappedCFException(h4, ex);
1763 +            rs[4].assertNotInvoked();
1764 +        }
1765 +        try {
1766 +            assertEquals(inc(v1), h5.join());
1767 +            rs[5].assertInvoked();
1768 +        } catch (CompletionException ok) {
1769 +            checkCompletedWithWrappedCFException(h5, ex);
1770 +            rs[5].assertNotInvoked();
1771          }
1217    }
1772  
1773 <    public void testThenCombine_sourceCancelled4() {
1773 >        checkCompletedWithWrappedCFException(f, ex);
1774 >        checkCompletedNormally(g, v1);
1775 >        checkCompletedWithWrappedCFException(h0, ex);
1776 >        checkCompletedWithWrappedCFException(h1, ex);
1777 >        checkCompletedWithWrappedCFException(h2, ex);
1778 >        checkCompletedWithWrappedCFException(h3, ex);
1779 >        checkCompletedWithWrappedCFException(h4, ex);
1780 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1781 >    }}
1782 >
1783 >    /**
1784 >     * applyToEither result completes exceptionally if either source cancelled
1785 >     */
1786 >    public void testApplyToEither_sourceCancelled() {
1787          for (ExecutionMode m : ExecutionMode.values())
1788          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1789 <        for (Integer v1 : new Integer[] { 1, null }) {
1790 <
1789 >        for (Integer v1 : new Integer[] { 1, null })
1790 >    {
1791          final CompletableFuture<Integer> f = new CompletableFuture<>();
1792          final CompletableFuture<Integer> g = new CompletableFuture<>();
1793 <        final SubtractFunction r = new SubtractFunction();
1793 >        final IncFunction[] rs = new IncFunction[6];
1794 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1795  
1796 <        assertTrue(f.cancel(mayInterruptIfRunning));
1796 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1797 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1798 >        checkIncomplete(h0);
1799 >        checkIncomplete(h1);
1800 >        rs[0].assertNotInvoked();
1801 >        rs[1].assertNotInvoked();
1802 >        f.cancel(mayInterruptIfRunning);
1803 >        checkCompletedWithWrappedCancellationException(h0);
1804 >        checkCompletedWithWrappedCancellationException(h1);
1805 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1806 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1807 >        checkCompletedWithWrappedCancellationException(h2);
1808 >        checkCompletedWithWrappedCancellationException(h3);
1809          g.complete(v1);
1230        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1810  
1811 <        checkCompletedWithWrappedCancellationException(h);
1811 >        // unspecified behavior - both source completions available
1812 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1813 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1814 >        try {
1815 >            assertEquals(inc(v1), h4.join());
1816 >            rs[4].assertInvoked();
1817 >        } catch (CompletionException ok) {
1818 >            checkCompletedWithWrappedCancellationException(h4);
1819 >            rs[4].assertNotInvoked();
1820 >        }
1821 >        try {
1822 >            assertEquals(inc(v1), h5.join());
1823 >            rs[5].assertInvoked();
1824 >        } catch (CompletionException ok) {
1825 >            checkCompletedWithWrappedCancellationException(h5);
1826 >            rs[5].assertNotInvoked();
1827 >        }
1828 >
1829          checkCancelled(f);
1234        assertFalse(r.ran());
1830          checkCompletedNormally(g, v1);
1831 <        }
1832 <    }
1831 >        checkCompletedWithWrappedCancellationException(h0);
1832 >        checkCompletedWithWrappedCancellationException(h1);
1833 >        checkCompletedWithWrappedCancellationException(h2);
1834 >        checkCompletedWithWrappedCancellationException(h3);
1835 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1836 >    }}
1837  
1838      /**
1839 <     * thenAcceptBoth result completes normally after normal
1241 <     * completion of sources
1839 >     * applyToEither result completes exceptionally if action does
1840       */
1841 <    public void testThenAcceptBoth_normalCompletion1() {
1841 >    public void testApplyToEither_actionFailed() {
1842          for (ExecutionMode m : ExecutionMode.values())
1843          for (Integer v1 : new Integer[] { 1, null })
1844 <        for (Integer v2 : new Integer[] { 2, null }) {
1845 <
1844 >        for (Integer v2 : new Integer[] { 2, null })
1845 >    {
1846          final CompletableFuture<Integer> f = new CompletableFuture<>();
1847          final CompletableFuture<Integer> g = new CompletableFuture<>();
1848 <        final SubtractAction r = new SubtractAction();
1849 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1848 >        final FailingFunction[] rs = new FailingFunction[6];
1849 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1850  
1851 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1852 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1853          f.complete(v1);
1854 <        checkIncomplete(h);
1855 <        assertFalse(r.ran());
1854 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1855 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1856          g.complete(v2);
1857 <
1858 <        checkCompletedNormally(h, null);
1859 <        assertEquals(r.value, subtract(v1, v2));
1857 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1858 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1859 >        
1860          checkCompletedNormally(f, v1);
1861          checkCompletedNormally(g, v2);
1862 <        }
1863 <    }
1862 >        checkCompletedWithWrappedCFException(h0);
1863 >        checkCompletedWithWrappedCFException(h1);
1864 >        checkCompletedWithWrappedCFException(h2);
1865 >        checkCompletedWithWrappedCFException(h3);
1866 >        checkCompletedWithWrappedCFException(h4);
1867 >        checkCompletedWithWrappedCFException(h5);
1868 >        for (int i = 0; i < rs.length; i++) rs[i].assertInvoked();
1869 >    }}
1870  
1871 <    public void testThenAcceptBoth_normalCompletion2() {
1871 >    /**
1872 >     * acceptEither result completes normally after normal completion
1873 >     * of either source
1874 >     */
1875 >    public void testAcceptEither_normalCompletion1() {
1876          for (ExecutionMode m : ExecutionMode.values())
1877          for (Integer v1 : new Integer[] { 1, null })
1878 <        for (Integer v2 : new Integer[] { 2, null }) {
1879 <
1878 >        for (Integer v2 : new Integer[] { 2, null })
1879 >    {
1880          final CompletableFuture<Integer> f = new CompletableFuture<>();
1881          final CompletableFuture<Integer> g = new CompletableFuture<>();
1882 <        final SubtractAction r = new SubtractAction();
1883 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1882 >        final IncAction r = new IncAction(m);
1883 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1884  
1275        g.complete(v2);
1276        checkIncomplete(h);
1277        assertFalse(r.ran());
1885          f.complete(v1);
1279
1886          checkCompletedNormally(h, null);
1887 <        assertEquals(r.value, subtract(v1, v2));
1887 >        assertEquals(inc(v1), r.value);
1888 >        g.complete(v2);
1889 >
1890          checkCompletedNormally(f, v1);
1891          checkCompletedNormally(g, v2);
1892 <        }
1893 <    }
1892 >        checkCompletedNormally(h, null);
1893 >    }}
1894  
1895 <    public void testThenAcceptBoth_normalCompletion3() {
1895 >    public void testAcceptEither_normalCompletion2() {
1896          for (ExecutionMode m : ExecutionMode.values())
1897          for (Integer v1 : new Integer[] { 1, null })
1898 <        for (Integer v2 : new Integer[] { 2, null }) {
1899 <
1898 >        for (Integer v2 : new Integer[] { 2, null })
1899 >    {
1900          final CompletableFuture<Integer> f = new CompletableFuture<>();
1901          final CompletableFuture<Integer> g = new CompletableFuture<>();
1902 <        final SubtractAction r = new SubtractAction();
1902 >        final IncAction r = new IncAction(m);
1903 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1904  
1905          g.complete(v2);
1906 +        checkCompletedNormally(h, null);
1907 +        assertEquals(inc(v2), r.value);
1908          f.complete(v1);
1298        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1909  
1300        checkCompletedNormally(h, null);
1301        assertEquals(r.value, subtract(v1, v2));
1910          checkCompletedNormally(f, v1);
1911          checkCompletedNormally(g, v2);
1912 <        }
1913 <    }
1912 >        checkCompletedNormally(h, null);
1913 >    }}
1914  
1915 <    public void testThenAcceptBoth_normalCompletion4() {
1915 >    public void testAcceptEither_normalCompletion3() {
1916          for (ExecutionMode m : ExecutionMode.values())
1917          for (Integer v1 : new Integer[] { 1, null })
1918 <        for (Integer v2 : new Integer[] { 2, null }) {
1919 <
1918 >        for (Integer v2 : new Integer[] { 2, null })
1919 >    {
1920          final CompletableFuture<Integer> f = new CompletableFuture<>();
1921          final CompletableFuture<Integer> g = new CompletableFuture<>();
1922 <        final SubtractAction r = new SubtractAction();
1922 >        final IncAction r = new IncAction(m);
1923  
1924          f.complete(v1);
1925          g.complete(v2);
1926 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1926 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1927  
1928          checkCompletedNormally(h, null);
1321        assertEquals(r.value, subtract(v1, v2));
1929          checkCompletedNormally(f, v1);
1930          checkCompletedNormally(g, v2);
1931 <        }
1932 <    }
1931 >
1932 >        // unspecified behavior
1933 >        assertTrue(Objects.equals(r.value, inc(v1)) ||
1934 >                   Objects.equals(r.value, inc(v2)));
1935 >    }}
1936  
1937      /**
1938 <     * thenAcceptBoth result completes exceptionally after exceptional
1938 >     * acceptEither result completes exceptionally after exceptional
1939       * completion of either source
1940       */
1941 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1941 >    public void testAcceptEither_exceptionalCompletion1() {
1942          for (ExecutionMode m : ExecutionMode.values())
1943 <        for (Integer v1 : new Integer[] { 1, null }) {
1944 <
1943 >        for (Integer v1 : new Integer[] { 1, null })
1944 >    {
1945          final CompletableFuture<Integer> f = new CompletableFuture<>();
1946          final CompletableFuture<Integer> g = new CompletableFuture<>();
1947 <        final SubtractAction r = new SubtractAction();
1948 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1947 >        final IncAction r = new IncAction(m);
1948 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1949          final CFException ex = new CFException();
1950  
1951          f.completeExceptionally(ex);
1952 <        checkIncomplete(h);
1952 >        checkCompletedWithWrappedCFException(h, ex);
1953          g.complete(v1);
1954  
1955 <        checkCompletedWithWrappedCFException(h, ex);
1346 <        checkCompletedWithWrappedCFException(f, ex);
1347 <        assertFalse(r.ran());
1955 >        r.assertNotInvoked();
1956          checkCompletedNormally(g, v1);
1957 <        }
1958 <    }
1957 >        checkCompletedWithWrappedCFException(f, ex);
1958 >        checkCompletedWithWrappedCFException(h, ex);
1959 >    }}
1960  
1961 <    public void testThenAcceptBoth_exceptionalCompletion2() {
1961 >    public void testAcceptEither_exceptionalCompletion2() {
1962          for (ExecutionMode m : ExecutionMode.values())
1963 <        for (Integer v1 : new Integer[] { 1, null }) {
1964 <
1963 >        for (Integer v1 : new Integer[] { 1, null })
1964 >    {
1965          final CompletableFuture<Integer> f = new CompletableFuture<>();
1966          final CompletableFuture<Integer> g = new CompletableFuture<>();
1967 <        final SubtractAction r = new SubtractAction();
1968 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1967 >        final IncAction r = new IncAction(m);
1968 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1969          final CFException ex = new CFException();
1970  
1971          g.completeExceptionally(ex);
1972 <        checkIncomplete(h);
1972 >        checkCompletedWithWrappedCFException(h, ex);
1973          f.complete(v1);
1974  
1975 <        checkCompletedWithWrappedCFException(h, ex);
1367 <        checkCompletedWithWrappedCFException(g, ex);
1368 <        assertFalse(r.ran());
1975 >        r.assertNotInvoked();
1976          checkCompletedNormally(f, v1);
1977 <        }
1978 <    }
1977 >        checkCompletedWithWrappedCFException(g, ex);
1978 >        checkCompletedWithWrappedCFException(h, ex);
1979 >    }}
1980  
1981 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1981 >    public void testAcceptEither_exceptionalCompletion3() {
1982          for (ExecutionMode m : ExecutionMode.values())
1983 <        for (Integer v1 : new Integer[] { 1, null }) {
1984 <
1983 >        for (Integer v1 : new Integer[] { 1, null })
1984 >    {
1985          final CompletableFuture<Integer> f = new CompletableFuture<>();
1986          final CompletableFuture<Integer> g = new CompletableFuture<>();
1987 <        final SubtractAction r = new SubtractAction();
1987 >        final IncAction r = new IncAction(m);
1988          final CFException ex = new CFException();
1989  
1990          g.completeExceptionally(ex);
1991          f.complete(v1);
1992 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1992 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1993 >
1994 >        // unspecified behavior
1995 >        Integer v;
1996 >        try {
1997 >            assertNull(h.join());
1998 >            r.assertInvoked();
1999 >            assertEquals(inc(v1), r.value);
2000 >        } catch (CompletionException ok) {
2001 >            checkCompletedWithWrappedCFException(h, ex);
2002 >            r.assertNotInvoked();
2003 >        }
2004  
1386        checkCompletedWithWrappedCFException(h, ex);
2005          checkCompletedWithWrappedCFException(g, ex);
1388        assertFalse(r.ran());
2006          checkCompletedNormally(f, v1);
2007 <        }
1391 <    }
2007 >    }}
2008  
2009 <    public void testThenAcceptBoth_exceptionalCompletion4() {
2009 >    public void testAcceptEither_exceptionalCompletion4() {
2010          for (ExecutionMode m : ExecutionMode.values())
2011 <        for (Integer v1 : new Integer[] { 1, null }) {
2012 <
2011 >        for (Integer v1 : new Integer[] { 1, null })
2012 >    {
2013          final CompletableFuture<Integer> f = new CompletableFuture<>();
2014          final CompletableFuture<Integer> g = new CompletableFuture<>();
2015 <        final SubtractAction r = new SubtractAction();
2015 >        final IncAction r = new IncAction(m);
2016          final CFException ex = new CFException();
2017  
2018          f.completeExceptionally(ex);
2019          g.complete(v1);
2020 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2020 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2021 >
2022 >        // unspecified behavior
2023 >        Integer v;
2024 >        try {
2025 >            assertNull(h.join());
2026 >            r.assertInvoked();
2027 >            assertEquals(inc(v1), r.value);
2028 >        } catch (CompletionException ok) {
2029 >            checkCompletedWithWrappedCFException(h, ex);
2030 >            r.assertNotInvoked();
2031 >        }
2032  
1406        checkCompletedWithWrappedCFException(h, ex);
2033          checkCompletedWithWrappedCFException(f, ex);
1408        assertFalse(r.ran());
2034          checkCompletedNormally(g, v1);
2035 <        }
1411 <    }
2035 >    }}
2036  
2037      /**
2038 <     * thenAcceptBoth result completes exceptionally if action does
2038 >     * acceptEither result completes exceptionally if action does
2039       */
2040 <    public void testThenAcceptBoth_actionFailed1() {
2040 >    public void testAcceptEither_actionFailed1() {
2041          for (ExecutionMode m : ExecutionMode.values())
2042          for (Integer v1 : new Integer[] { 1, null })
2043 <        for (Integer v2 : new Integer[] { 2, null }) {
2044 <
2043 >        for (Integer v2 : new Integer[] { 2, null })
2044 >    {
2045          final CompletableFuture<Integer> f = new CompletableFuture<>();
2046          final CompletableFuture<Integer> g = new CompletableFuture<>();
2047 <        final FailingBiConsumer r = new FailingBiConsumer();
2048 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2047 >        final FailingConsumer r = new FailingConsumer(m);
2048 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2049  
2050          f.complete(v1);
1427        checkIncomplete(h);
1428        g.complete(v2);
1429
2051          checkCompletedWithWrappedCFException(h);
2052 +        g.complete(v2);
2053          checkCompletedNormally(f, v1);
2054          checkCompletedNormally(g, v2);
2055 <        }
1434 <    }
2055 >    }}
2056  
2057 <    public void testThenAcceptBoth_actionFailed2() {
2057 >    public void testAcceptEither_actionFailed2() {
2058          for (ExecutionMode m : ExecutionMode.values())
2059          for (Integer v1 : new Integer[] { 1, null })
2060 <        for (Integer v2 : new Integer[] { 2, null }) {
2061 <
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 FailingBiConsumer r = new FailingBiConsumer();
2065 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2064 >        final FailingConsumer r = new FailingConsumer(m);
2065 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2066  
2067          g.complete(v2);
1447        checkIncomplete(h);
1448        f.complete(v1);
1449
2068          checkCompletedWithWrappedCFException(h);
2069 +        f.complete(v1);
2070          checkCompletedNormally(f, v1);
2071          checkCompletedNormally(g, v2);
2072 <        }
1454 <    }
2072 >    }}
2073  
2074      /**
2075 <     * thenAcceptBoth result completes exceptionally if either source cancelled
2075 >     * acceptEither result completes exceptionally if either source cancelled
2076       */
2077 <    public void testThenAcceptBoth_sourceCancelled1() {
2077 >    public void testAcceptEither_sourceCancelled1() {
2078          for (ExecutionMode m : ExecutionMode.values())
2079          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2080 <        for (Integer v1 : new Integer[] { 1, null }) {
2081 <
2080 >        for (Integer v1 : new Integer[] { 1, null })
2081 >    {
2082          final CompletableFuture<Integer> f = new CompletableFuture<>();
2083          final CompletableFuture<Integer> g = new CompletableFuture<>();
2084 <        final SubtractAction r = new SubtractAction();
2085 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2084 >        final IncAction r = new IncAction(m);
2085 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2086  
2087          assertTrue(f.cancel(mayInterruptIfRunning));
2088 <        checkIncomplete(h);
2088 >        checkCompletedWithWrappedCancellationException(h);
2089          g.complete(v1);
2090  
1473        checkCompletedWithWrappedCancellationException(h);
2091          checkCancelled(f);
2092 <        assertFalse(r.ran());
2092 >        r.assertNotInvoked();
2093          checkCompletedNormally(g, v1);
2094 <        }
2095 <    }
2094 >        checkCompletedWithWrappedCancellationException(h);
2095 >    }}
2096  
2097 <    public void testThenAcceptBoth_sourceCancelled2() {
2097 >    public void testAcceptEither_sourceCancelled2() {
2098          for (ExecutionMode m : ExecutionMode.values())
2099          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2100 <        for (Integer v1 : new Integer[] { 1, null }) {
2101 <
2100 >        for (Integer v1 : new Integer[] { 1, null })
2101 >    {
2102          final CompletableFuture<Integer> f = new CompletableFuture<>();
2103          final CompletableFuture<Integer> g = new CompletableFuture<>();
2104 <        final SubtractAction r = new SubtractAction();
2105 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2104 >        final IncAction r = new IncAction(m);
2105 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2106  
2107          assertTrue(g.cancel(mayInterruptIfRunning));
2108 <        checkIncomplete(h);
2108 >        checkCompletedWithWrappedCancellationException(h);
2109          f.complete(v1);
2110  
1494        checkCompletedWithWrappedCancellationException(h);
2111          checkCancelled(g);
2112 <        assertFalse(r.ran());
2112 >        r.assertNotInvoked();
2113          checkCompletedNormally(f, v1);
2114 <        }
2115 <    }
2114 >        checkCompletedWithWrappedCancellationException(h);
2115 >    }}
2116  
2117 <    public void testThenAcceptBoth_sourceCancelled3() {
2117 >    public void testAcceptEither_sourceCancelled3() {
2118          for (ExecutionMode m : ExecutionMode.values())
2119          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2120 <        for (Integer v1 : new Integer[] { 1, null }) {
2121 <
2120 >        for (Integer v1 : new Integer[] { 1, null })
2121 >    {
2122          final CompletableFuture<Integer> f = new CompletableFuture<>();
2123          final CompletableFuture<Integer> g = new CompletableFuture<>();
2124 <        final SubtractAction r = new SubtractAction();
2124 >        final IncAction r = new IncAction(m);
2125  
2126          assertTrue(g.cancel(mayInterruptIfRunning));
2127          f.complete(v1);
2128 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2128 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2129 >
2130 >        // unspecified behavior
2131 >        Integer v;
2132 >        try {
2133 >            assertNull(h.join());
2134 >            r.assertInvoked();
2135 >            assertEquals(inc(v1), r.value);
2136 >        } catch (CompletionException ok) {
2137 >            checkCompletedWithWrappedCancellationException(h);
2138 >            r.assertNotInvoked();
2139 >        }
2140  
1514        checkCompletedWithWrappedCancellationException(h);
2141          checkCancelled(g);
1516        assertFalse(r.ran());
2142          checkCompletedNormally(f, v1);
2143 <        }
1519 <    }
2143 >    }}
2144  
2145 <    public void testThenAcceptBoth_sourceCancelled4() {
2145 >    public void testAcceptEither_sourceCancelled4() {
2146          for (ExecutionMode m : ExecutionMode.values())
2147          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2148 <        for (Integer v1 : new Integer[] { 1, null }) {
2149 <
2148 >        for (Integer v1 : new Integer[] { 1, null })
2149 >    {
2150          final CompletableFuture<Integer> f = new CompletableFuture<>();
2151          final CompletableFuture<Integer> g = new CompletableFuture<>();
2152 <        final SubtractAction r = new SubtractAction();
2152 >        final IncAction r = new IncAction(m);
2153  
2154          assertTrue(f.cancel(mayInterruptIfRunning));
2155          g.complete(v1);
2156 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
2156 >        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2157 >
2158 >        // unspecified behavior
2159 >        Integer v;
2160 >        try {
2161 >            assertNull(h.join());
2162 >            r.assertInvoked();
2163 >            assertEquals(inc(v1), r.value);
2164 >        } catch (CompletionException ok) {
2165 >            checkCompletedWithWrappedCancellationException(h);
2166 >            r.assertNotInvoked();
2167 >        }
2168  
1534        checkCompletedWithWrappedCancellationException(h);
2169          checkCancelled(f);
1536        assertFalse(r.ran());
2170          checkCompletedNormally(g, v1);
2171 <        }
1539 <    }
2171 >    }}
2172  
2173      /**
2174 <     * runAfterBoth result completes normally after normal
2175 <     * completion of sources
2174 >     * runAfterEither result completes normally after normal completion
2175 >     * of either source
2176       */
2177 <    public void testRunAfterBoth_normalCompletion1() {
2177 >    public void testRunAfterEither_normalCompletion1() {
2178          for (ExecutionMode m : ExecutionMode.values())
2179          for (Integer v1 : new Integer[] { 1, null })
2180 <        for (Integer v2 : new Integer[] { 2, null }) {
2181 <
2180 >        for (Integer v2 : new Integer[] { 2, null })
2181 >    {
2182          final CompletableFuture<Integer> f = new CompletableFuture<>();
2183          final CompletableFuture<Integer> g = new CompletableFuture<>();
2184 <        final Noop r = new Noop();
2185 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2184 >        final Noop r = new Noop(m);
2185 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2186  
2187          f.complete(v1);
1556        checkIncomplete(h);
1557        assertFalse(r.ran);
1558        g.complete(v2);
1559
2188          checkCompletedNormally(h, null);
2189 <        assertTrue(r.ran);
1562 <        checkCompletedNormally(f, v1);
1563 <        checkCompletedNormally(g, v2);
1564 <        }
1565 <    }
1566 <
1567 <    public void testRunAfterBoth_normalCompletion2() {
1568 <        for (ExecutionMode m : ExecutionMode.values())
1569 <        for (Integer v1 : new Integer[] { 1, null })
1570 <        for (Integer v2 : new Integer[] { 2, null }) {
1571 <
1572 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1573 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1574 <        final Noop r = new Noop();
1575 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1576 <
2189 >        r.assertInvoked();
2190          g.complete(v2);
1578        checkIncomplete(h);
1579        assertFalse(r.ran);
1580        f.complete(v1);
2191  
1582        checkCompletedNormally(h, null);
1583        assertTrue(r.ran);
2192          checkCompletedNormally(f, v1);
2193          checkCompletedNormally(g, v2);
2194 <        }
2195 <    }
2194 >        checkCompletedNormally(h, null);
2195 >        r.assertInvoked();
2196 >    }}
2197  
2198 <    public void testRunAfterBoth_normalCompletion3() {
2198 >    public void testRunAfterEither_normalCompletion2() {
2199          for (ExecutionMode m : ExecutionMode.values())
2200          for (Integer v1 : new Integer[] { 1, null })
2201 <        for (Integer v2 : new Integer[] { 2, null }) {
2202 <
2201 >        for (Integer v2 : new Integer[] { 2, null })
2202 >    {
2203          final CompletableFuture<Integer> f = new CompletableFuture<>();
2204          final CompletableFuture<Integer> g = new CompletableFuture<>();
2205 <        final Noop r = new Noop();
2205 >        final Noop r = new Noop(m);
2206 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2207  
2208          g.complete(v2);
2209 +        checkCompletedNormally(h, null);
2210 +        r.assertInvoked();
2211          f.complete(v1);
1600        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2212  
1602        checkCompletedNormally(h, null);
1603        assertTrue(r.ran);
2213          checkCompletedNormally(f, v1);
2214          checkCompletedNormally(g, v2);
2215 <        }
2216 <    }
2215 >        checkCompletedNormally(h, null);
2216 >        r.assertInvoked();
2217 >        }}
2218  
2219 <    public void testRunAfterBoth_normalCompletion4() {
2219 >    public void testRunAfterEither_normalCompletion3() {
2220          for (ExecutionMode m : ExecutionMode.values())
2221          for (Integer v1 : new Integer[] { 1, null })
2222 <        for (Integer v2 : new Integer[] { 2, null }) {
2223 <
2222 >        for (Integer v2 : new Integer[] { 2, null })
2223 >    {
2224          final CompletableFuture<Integer> f = new CompletableFuture<>();
2225          final CompletableFuture<Integer> g = new CompletableFuture<>();
2226 <        final Noop r = new Noop();
2226 >        final Noop r = new Noop(m);
2227  
2228          f.complete(v1);
2229          g.complete(v2);
2230 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2230 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2231  
2232          checkCompletedNormally(h, null);
1623        assertTrue(r.ran);
2233          checkCompletedNormally(f, v1);
2234          checkCompletedNormally(g, v2);
2235 <        }
2236 <    }
2235 >        r.assertInvoked();
2236 >    }}
2237  
2238      /**
2239 <     * runAfterBoth result completes exceptionally after exceptional
2239 >     * runAfterEither result completes exceptionally after exceptional
2240       * completion of either source
2241       */
2242 <    public void testRunAfterBoth_exceptionalCompletion1() {
2242 >    public void testRunAfterEither_exceptionalCompletion1() {
2243          for (ExecutionMode m : ExecutionMode.values())
2244 <        for (Integer v1 : new Integer[] { 1, null }) {
2245 <
2244 >        for (Integer v1 : new Integer[] { 1, null })
2245 >    {
2246          final CompletableFuture<Integer> f = new CompletableFuture<>();
2247          final CompletableFuture<Integer> g = new CompletableFuture<>();
2248 <        final Noop r = new Noop();
2249 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2248 >        final Noop r = new Noop(m);
2249 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2250          final CFException ex = new CFException();
2251  
2252          f.completeExceptionally(ex);
2253 <        checkIncomplete(h);
2253 >        checkCompletedWithWrappedCFException(h, ex);
2254          g.complete(v1);
2255  
2256 <        checkCompletedWithWrappedCFException(h, ex);
1648 <        checkCompletedWithWrappedCFException(f, ex);
1649 <        assertFalse(r.ran);
2256 >        r.assertNotInvoked();
2257          checkCompletedNormally(g, v1);
2258 <        }
2259 <    }
2258 >        checkCompletedWithWrappedCFException(f, ex);
2259 >        checkCompletedWithWrappedCFException(h, ex);
2260 >    }}
2261  
2262 <    public void testRunAfterBoth_exceptionalCompletion2() {
2262 >    public void testRunAfterEither_exceptionalCompletion2() {
2263          for (ExecutionMode m : ExecutionMode.values())
2264 <        for (Integer v1 : new Integer[] { 1, null }) {
2265 <
2264 >        for (Integer v1 : new Integer[] { 1, null })
2265 >    {
2266          final CompletableFuture<Integer> f = new CompletableFuture<>();
2267          final CompletableFuture<Integer> g = new CompletableFuture<>();
2268 <        final Noop r = new Noop();
2269 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2268 >        final Noop r = new Noop(m);
2269 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2270          final CFException ex = new CFException();
2271  
2272          g.completeExceptionally(ex);
2273 <        checkIncomplete(h);
2273 >        checkCompletedWithWrappedCFException(h, ex);
2274          f.complete(v1);
2275  
2276 <        checkCompletedWithWrappedCFException(h, ex);
1669 <        checkCompletedWithWrappedCFException(g, ex);
1670 <        assertFalse(r.ran);
2276 >        r.assertNotInvoked();
2277          checkCompletedNormally(f, v1);
2278 <        }
2279 <    }
2278 >        checkCompletedWithWrappedCFException(g, ex);
2279 >        checkCompletedWithWrappedCFException(h, ex);
2280 >    }}
2281  
2282 <    public void testRunAfterBoth_exceptionalCompletion3() {
2282 >    public void testRunAfterEither_exceptionalCompletion3() {
2283          for (ExecutionMode m : ExecutionMode.values())
2284 <        for (Integer v1 : new Integer[] { 1, null }) {
2285 <
2284 >        for (Integer v1 : new Integer[] { 1, null })
2285 >    {
2286          final CompletableFuture<Integer> f = new CompletableFuture<>();
2287          final CompletableFuture<Integer> g = new CompletableFuture<>();
2288 <        final Noop r = new Noop();
2288 >        final Noop r = new Noop(m);
2289          final CFException ex = new CFException();
2290  
2291          g.completeExceptionally(ex);
2292          f.complete(v1);
2293 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2293 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2294 >
2295 >        // unspecified behavior
2296 >        Integer v;
2297 >        try {
2298 >            assertNull(h.join());
2299 >            r.assertInvoked();
2300 >        } catch (CompletionException ok) {
2301 >            checkCompletedWithWrappedCFException(h, ex);
2302 >            r.assertNotInvoked();
2303 >        }
2304  
1688        checkCompletedWithWrappedCFException(h, ex);
2305          checkCompletedWithWrappedCFException(g, ex);
1690        assertFalse(r.ran);
2306          checkCompletedNormally(f, v1);
2307 <        }
1693 <    }
2307 >    }}
2308  
2309 <    public void testRunAfterBoth_exceptionalCompletion4() {
2309 >    public void testRunAfterEither_exceptionalCompletion4() {
2310          for (ExecutionMode m : ExecutionMode.values())
2311 <        for (Integer v1 : new Integer[] { 1, null }) {
2312 <
2311 >        for (Integer v1 : new Integer[] { 1, null })
2312 >    {
2313          final CompletableFuture<Integer> f = new CompletableFuture<>();
2314          final CompletableFuture<Integer> g = new CompletableFuture<>();
2315 <        final Noop r = new Noop();
2315 >        final Noop r = new Noop(m);
2316          final CFException ex = new CFException();
2317  
2318          f.completeExceptionally(ex);
2319          g.complete(v1);
2320 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2320 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2321 >
2322 >        // unspecified behavior
2323 >        Integer v;
2324 >        try {
2325 >            assertNull(h.join());
2326 >            r.assertInvoked();
2327 >        } catch (CompletionException ok) {
2328 >            checkCompletedWithWrappedCFException(h, ex);
2329 >            r.assertNotInvoked();
2330 >        }
2331  
1708        checkCompletedWithWrappedCFException(h, ex);
2332          checkCompletedWithWrappedCFException(f, ex);
1710        assertFalse(r.ran);
2333          checkCompletedNormally(g, v1);
2334 <        }
1713 <    }
2334 >    }}
2335  
2336      /**
2337 <     * runAfterBoth result completes exceptionally if action does
2337 >     * runAfterEither result completes exceptionally if action does
2338       */
2339 <    public void testRunAfterBoth_actionFailed1() {
2339 >    public void testRunAfterEither_actionFailed1() {
2340          for (ExecutionMode m : ExecutionMode.values())
2341          for (Integer v1 : new Integer[] { 1, null })
2342 <        for (Integer v2 : new Integer[] { 2, null }) {
2343 <
2342 >        for (Integer v2 : new Integer[] { 2, null })
2343 >    {
2344          final CompletableFuture<Integer> f = new CompletableFuture<>();
2345          final CompletableFuture<Integer> g = new CompletableFuture<>();
2346 <        final FailingNoop r = new FailingNoop();
2347 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2346 >        final FailingRunnable r = new FailingRunnable(m);
2347 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2348  
2349          f.complete(v1);
1729        checkIncomplete(h);
1730        g.complete(v2);
1731
2350          checkCompletedWithWrappedCFException(h);
2351 +        g.complete(v2);
2352          checkCompletedNormally(f, v1);
2353          checkCompletedNormally(g, v2);
2354 <        }
1736 <    }
2354 >    }}
2355  
2356 <    public void testRunAfterBoth_actionFailed2() {
2356 >    public void testRunAfterEither_actionFailed2() {
2357          for (ExecutionMode m : ExecutionMode.values())
2358          for (Integer v1 : new Integer[] { 1, null })
2359 <        for (Integer v2 : new Integer[] { 2, null }) {
2360 <
2359 >        for (Integer v2 : new Integer[] { 2, null })
2360 >    {
2361          final CompletableFuture<Integer> f = new CompletableFuture<>();
2362          final CompletableFuture<Integer> g = new CompletableFuture<>();
2363 <        final FailingNoop r = new FailingNoop();
2364 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2363 >        final FailingRunnable r = new FailingRunnable(m);
2364 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2365  
2366          g.complete(v2);
1749        checkIncomplete(h);
1750        f.complete(v1);
1751
2367          checkCompletedWithWrappedCFException(h);
2368 +        f.complete(v1);
2369          checkCompletedNormally(f, v1);
2370          checkCompletedNormally(g, v2);
2371 <        }
1756 <    }
2371 >    }}
2372  
2373      /**
2374 <     * runAfterBoth result completes exceptionally if either source cancelled
2374 >     * runAfterEither result completes exceptionally if either source cancelled
2375       */
2376 <    public void testRunAfterBoth_sourceCancelled1() {
2376 >    public void testRunAfterEither_sourceCancelled1() {
2377          for (ExecutionMode m : ExecutionMode.values())
2378          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2379 <        for (Integer v1 : new Integer[] { 1, null }) {
2380 <
2379 >        for (Integer v1 : new Integer[] { 1, null })
2380 >    {
2381          final CompletableFuture<Integer> f = new CompletableFuture<>();
2382          final CompletableFuture<Integer> g = new CompletableFuture<>();
2383 <        final Noop r = new Noop();
2384 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2383 >        final Noop r = new Noop(m);
2384 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2385  
2386          assertTrue(f.cancel(mayInterruptIfRunning));
2387 <        checkIncomplete(h);
2387 >        checkCompletedWithWrappedCancellationException(h);
2388          g.complete(v1);
2389  
1775        checkCompletedWithWrappedCancellationException(h);
2390          checkCancelled(f);
2391 <        assertFalse(r.ran);
2391 >        r.assertNotInvoked();
2392          checkCompletedNormally(g, v1);
2393 <        }
2394 <    }
2393 >        checkCompletedWithWrappedCancellationException(h);
2394 >    }}
2395  
2396 <    public void testRunAfterBoth_sourceCancelled2() {
2396 >    public void testRunAfterEither_sourceCancelled2() {
2397          for (ExecutionMode m : ExecutionMode.values())
2398          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2399 <        for (Integer v1 : new Integer[] { 1, null }) {
2400 <
2399 >        for (Integer v1 : new Integer[] { 1, null })
2400 >    {
2401          final CompletableFuture<Integer> f = new CompletableFuture<>();
2402          final CompletableFuture<Integer> g = new CompletableFuture<>();
2403 <        final Noop r = new Noop();
2404 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2403 >        final Noop r = new Noop(m);
2404 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2405  
2406          assertTrue(g.cancel(mayInterruptIfRunning));
2407 <        checkIncomplete(h);
2407 >        checkCompletedWithWrappedCancellationException(h);
2408          f.complete(v1);
2409  
1796        checkCompletedWithWrappedCancellationException(h);
2410          checkCancelled(g);
2411 <        assertFalse(r.ran);
2411 >        r.assertNotInvoked();
2412          checkCompletedNormally(f, v1);
2413 <        }
2414 <    }
2413 >        checkCompletedWithWrappedCancellationException(h);
2414 >    }}
2415  
2416 <    public void testRunAfterBoth_sourceCancelled3() {
2416 >    public void testRunAfterEither_sourceCancelled3() {
2417          for (ExecutionMode m : ExecutionMode.values())
2418          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2419 <        for (Integer v1 : new Integer[] { 1, null }) {
2420 <
2419 >        for (Integer v1 : new Integer[] { 1, null })
2420 >    {
2421          final CompletableFuture<Integer> f = new CompletableFuture<>();
2422          final CompletableFuture<Integer> g = new CompletableFuture<>();
2423 <        final Noop r = new Noop();
2423 >        final Noop r = new Noop(m);
2424  
2425          assertTrue(g.cancel(mayInterruptIfRunning));
2426          f.complete(v1);
2427 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2427 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2428 >
2429 >        // unspecified behavior
2430 >        Integer v;
2431 >        try {
2432 >            assertNull(h.join());
2433 >            r.assertInvoked();
2434 >        } catch (CompletionException ok) {
2435 >            checkCompletedWithWrappedCancellationException(h);
2436 >            r.assertNotInvoked();
2437 >        }
2438  
1816        checkCompletedWithWrappedCancellationException(h);
2439          checkCancelled(g);
1818        assertFalse(r.ran);
2440          checkCompletedNormally(f, v1);
2441 <        }
1821 <    }
2441 >    }}
2442  
2443 <    public void testRunAfterBoth_sourceCancelled4() {
2443 >    public void testRunAfterEither_sourceCancelled4() {
2444          for (ExecutionMode m : ExecutionMode.values())
2445          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2446 <        for (Integer v1 : new Integer[] { 1, null }) {
2447 <
2446 >        for (Integer v1 : new Integer[] { 1, null })
2447 >    {
2448          final CompletableFuture<Integer> f = new CompletableFuture<>();
2449          final CompletableFuture<Integer> g = new CompletableFuture<>();
2450 <        final Noop r = new Noop();
2450 >        final Noop r = new Noop(m);
2451  
2452          assertTrue(f.cancel(mayInterruptIfRunning));
2453          g.complete(v1);
2454 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2454 >        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2455  
2456 <        checkCompletedWithWrappedCancellationException(h);
2457 <        checkCancelled(f);
2458 <        assertFalse(r.ran);
2459 <        checkCompletedNormally(g, v1);
2456 >        // unspecified behavior
2457 >        Integer v;
2458 >        try {
2459 >            assertNull(h.join());
2460 >            r.assertInvoked();
2461 >        } catch (CompletionException ok) {
2462 >            checkCompletedWithWrappedCancellationException(h);
2463 >            r.assertNotInvoked();
2464          }
1841    }
1842
1843    /**
1844     * applyToEither result completes normally after normal completion
1845     * of either source
1846     */
1847    public void testApplyToEither() {
1848        CompletableFuture<Integer> f = new CompletableFuture<>();
1849        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1850        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1851        f.complete(one);
1852        checkCompletedNormally(g, two);
1853        f2.complete(one);
1854        checkCompletedNormally(g, two);
1855
1856        f = new CompletableFuture<>();
1857        f.complete(one);
1858        f2 = new CompletableFuture<>();
1859        g = f.applyToEither(f2, inc);
1860        checkCompletedNormally(g, two);
1861    }
1862
1863    /**
1864     * applyToEither result completes exceptionally after exceptional
1865     * completion of either source
1866     */
1867    public void testApplyToEither2() {
1868        CompletableFuture<Integer> f = new CompletableFuture<>();
1869        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1870        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1871        f.completeExceptionally(new CFException());
1872        f2.complete(one);
1873        checkCompletedWithWrappedCFException(g);
1874
1875        f = new CompletableFuture<>();
1876        f2 = new CompletableFuture<>();
1877        f2.completeExceptionally(new CFException());
1878        g = f.applyToEither(f2, inc);
1879        checkCompletedWithWrappedCFException(g);
1880    }
1881
1882    /**
1883     * applyToEither result completes exceptionally if action does
1884     */
1885    public void testApplyToEither3() {
1886        CompletableFuture<Integer> f = new CompletableFuture<>();
1887        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1888        FailingFunction r = new FailingFunction();
1889        CompletableFuture<Integer> g = f.applyToEither(f2, r);
1890        f2.complete(two);
1891        checkCompletedWithWrappedCFException(g);
1892    }
1893
1894    /**
1895     * applyToEither result completes exceptionally if either source cancelled
1896     */
1897    public void testApplyToEither4() {
1898        CompletableFuture<Integer> f = new CompletableFuture<>();
1899        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1900        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1901        assertTrue(f.cancel(true));
1902        checkCompletedWithWrappedCancellationException(g);
1903        f = new CompletableFuture<>();
1904        f2 = new CompletableFuture<>();
1905        assertTrue(f2.cancel(true));
1906        checkCompletedWithWrappedCancellationException(g);
1907    }
1908
1909    /**
1910     * acceptEither result completes normally after normal completion
1911     * of either source
1912     */
1913    public void testAcceptEither() {
1914        CompletableFuture<Integer> f = new CompletableFuture<>();
1915        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1916        IncAction r = new IncAction();
1917        CompletableFuture<Void> g = f.acceptEither(f2, r);
1918        f.complete(one);
1919        checkCompletedNormally(g, null);
1920        f2.complete(one);
1921        checkCompletedNormally(g, null);
1922        assertEquals(r.value, (Integer) 2);
1923
1924        r = new IncAction();
1925        f = new CompletableFuture<>();
1926        f.complete(one);
1927        f2 = new CompletableFuture<>();
1928        g = f.acceptEither(f2, r);
1929        checkCompletedNormally(g, null);
1930        assertEquals(r.value, (Integer) 2);
1931    }
1932
1933    /**
1934     * acceptEither result completes exceptionally after exceptional
1935     * completion of either source
1936     */
1937    public void testAcceptEither2() {
1938        CompletableFuture<Integer> f = new CompletableFuture<>();
1939        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1940        IncAction r = new IncAction();
1941        CompletableFuture<Void> g = f.acceptEither(f2, r);
1942        f.completeExceptionally(new CFException());
1943        f2.complete(one);
1944        checkCompletedWithWrappedCFException(g);
1945
1946        r = new IncAction();
1947        f = new CompletableFuture<>();
1948        f2 = new CompletableFuture<>();
1949        f2.completeExceptionally(new CFException());
1950        g = f.acceptEither(f2, r);
1951        checkCompletedWithWrappedCFException(g);
1952    }
1953
1954    /**
1955     * acceptEither result completes exceptionally if action does
1956     */
1957    public void testAcceptEither3() {
1958        CompletableFuture<Integer> f = new CompletableFuture<>();
1959        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1960        FailingConsumer r = new FailingConsumer();
1961        CompletableFuture<Void> g = f.acceptEither(f2, r);
1962        f2.complete(two);
1963        checkCompletedWithWrappedCFException(g);
1964    }
1965
1966    /**
1967     * acceptEither result completes exceptionally if either source cancelled
1968     */
1969    public void testAcceptEither4() {
1970        CompletableFuture<Integer> f = new CompletableFuture<>();
1971        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1972        IncAction r = new IncAction();
1973        CompletableFuture<Void> g = f.acceptEither(f2, r);
1974        assertTrue(f.cancel(true));
1975        checkCompletedWithWrappedCancellationException(g);
1976        f = new CompletableFuture<>();
1977        f2 = new CompletableFuture<>();
1978        assertTrue(f2.cancel(true));
1979        checkCompletedWithWrappedCancellationException(g);
1980    }
1981
1982    /**
1983     * runAfterEither result completes normally after normal completion
1984     * of either source
1985     */
1986    public void testRunAfterEither() {
1987        CompletableFuture<Integer> f = new CompletableFuture<>();
1988        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1989        Noop r = new Noop();
1990        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1991        f.complete(one);
1992        checkCompletedNormally(g, null);
1993        f2.complete(one);
1994        checkCompletedNormally(g, null);
1995        assertTrue(r.ran);
2465  
2466 <        r = new Noop();
2467 <        f = new CompletableFuture<>();
2468 <        f.complete(one);
2000 <        f2 = new CompletableFuture<>();
2001 <        g = f.runAfterEither(f2, r);
2002 <        checkCompletedNormally(g, null);
2003 <        assertTrue(r.ran);
2004 <    }
2005 <
2006 <    /**
2007 <     * runAfterEither result completes exceptionally after exceptional
2008 <     * completion of either source
2009 <     */
2010 <    public void testRunAfterEither2() {
2011 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2012 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2013 <        Noop r = new Noop();
2014 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2015 <        f.completeExceptionally(new CFException());
2016 <        f2.complete(one);
2017 <        checkCompletedWithWrappedCFException(g);
2018 <
2019 <        r = new Noop();
2020 <        f = new CompletableFuture<>();
2021 <        f2 = new CompletableFuture<>();
2022 <        f2.completeExceptionally(new CFException());
2023 <        g = f.runAfterEither(f2, r);
2024 <        checkCompletedWithWrappedCFException(g);
2025 <    }
2026 <
2027 <    /**
2028 <     * runAfterEither result completes exceptionally if action does
2029 <     */
2030 <    public void testRunAfterEither3() {
2031 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2032 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2033 <        FailingNoop r = new FailingNoop();
2034 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2035 <        f2.complete(two);
2036 <        checkCompletedWithWrappedCFException(g);
2037 <    }
2038 <
2039 <    /**
2040 <     * runAfterEither result completes exceptionally if either source cancelled
2041 <     */
2042 <    public void testRunAfterEither4() {
2043 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2044 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2045 <        Noop r = new Noop();
2046 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
2047 <        assertTrue(f.cancel(true));
2048 <        checkCompletedWithWrappedCancellationException(g);
2049 <        f = new CompletableFuture<>();
2050 <        f2 = new CompletableFuture<>();
2051 <        assertTrue(f2.cancel(true));
2052 <        checkCompletedWithWrappedCancellationException(g);
2053 <    }
2466 >        checkCancelled(f);
2467 >        checkCompletedNormally(g, v1);
2468 >    }}
2469  
2470      /**
2471       * thenCompose result completes normally after normal completion of source
2472       */
2473 <    public void testThenCompose() {
2474 <        CompletableFuture<Integer> f, g;
2475 <        CompletableFutureInc r;
2476 <
2477 <        f = new CompletableFuture<>();
2478 <        g = f.thenCompose(r = new CompletableFutureInc());
2479 <        f.complete(one);
2480 <        checkCompletedNormally(g, two);
2481 <        assertTrue(r.ran);
2473 >    public void testThenCompose_normalCompletion() {
2474 >        for (ExecutionMode m : ExecutionMode.values())
2475 >        for (boolean createIncomplete : new boolean[] { true, false })
2476 >        for (Integer v1 : new Integer[] { 1, null })
2477 >    {
2478 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2479 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2480 >        if (!createIncomplete) f.complete(v1);
2481 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2482 >        if (createIncomplete) f.complete(v1);
2483  
2484 <        f = new CompletableFuture<>();
2485 <        f.complete(one);
2486 <        g = f.thenCompose(r = new CompletableFutureInc());
2487 <        checkCompletedNormally(g, two);
2072 <        assertTrue(r.ran);
2073 <    }
2484 >        checkCompletedNormally(g, inc(v1));
2485 >        checkCompletedNormally(f, v1);
2486 >        r.assertInvoked();
2487 >    }}
2488  
2489      /**
2490       * thenCompose result completes exceptionally after exceptional
2491       * completion of source
2492       */
2493 <    public void testThenCompose2() {
2494 <        CompletableFuture<Integer> f, g;
2495 <        CompletableFutureInc r;
2496 <
2497 <        f = new CompletableFuture<>();
2498 <        g = f.thenCompose(r = new CompletableFutureInc());
2499 <        f.completeExceptionally(new CFException());
2500 <        checkCompletedWithWrappedCFException(g);
2493 >    public void testThenCompose_exceptionalCompletion() {
2494 >        for (ExecutionMode m : ExecutionMode.values())
2495 >        for (boolean createIncomplete : new boolean[] { true, false })
2496 >    {
2497 >        final CFException ex = new CFException();
2498 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2499 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2500 >        if (!createIncomplete) f.completeExceptionally(ex);
2501 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2502 >        if (createIncomplete) f.completeExceptionally(ex);
2503  
2504 <        f = new CompletableFuture<>();
2505 <        f.completeExceptionally(new CFException());
2506 <        g = f.thenCompose(r = new CompletableFutureInc());
2507 <        checkCompletedWithWrappedCFException(g);
2092 <    }
2504 >        checkCompletedWithWrappedCFException(g, ex);
2505 >        checkCompletedWithWrappedCFException(f, ex);
2506 >        r.assertNotInvoked();
2507 >    }}
2508  
2509      /**
2510       * thenCompose result completes exceptionally if action does
2511       */
2512 <    public void testThenCompose3() {
2513 <        CompletableFuture<Integer> f, g;
2514 <        FailingCompletableFutureFunction r;
2515 <
2516 <        f = new CompletableFuture<>();
2517 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2518 <        f.complete(one);
2519 <        checkCompletedWithWrappedCFException(g);
2512 >    public void testThenCompose_actionFailed() {
2513 >        for (ExecutionMode m : ExecutionMode.values())
2514 >        for (boolean createIncomplete : new boolean[] { true, false })
2515 >        for (Integer v1 : new Integer[] { 1, null })
2516 >    {
2517 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2518 >        final FailingCompletableFutureFunction r
2519 >            = new FailingCompletableFutureFunction(m);
2520 >        if (!createIncomplete) f.complete(v1);
2521 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2522 >        if (createIncomplete) f.complete(v1);
2523  
2106        f = new CompletableFuture<>();
2107        f.complete(one);
2108        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2524          checkCompletedWithWrappedCFException(g);
2525 <    }
2525 >        checkCompletedNormally(f, v1);
2526 >    }}
2527  
2528      /**
2529       * thenCompose result completes exceptionally if source cancelled
2530       */
2531 <    public void testThenCompose4() {
2532 <        CompletableFuture<Integer> f, g;
2533 <        CompletableFutureInc r;
2534 <
2535 <        f = new CompletableFuture<>();
2536 <        g = f.thenCompose(r = new CompletableFutureInc());
2537 <        assertTrue(f.cancel(true));
2538 <        checkCompletedWithWrappedCancellationException(g);
2539 <
2540 <        f = new CompletableFuture<>();
2541 <        assertTrue(f.cancel(true));
2542 <        g = f.thenCompose(r = new CompletableFutureInc());
2543 <        checkCompletedWithWrappedCancellationException(g);
2128 <    }
2129 <
2130 <    // asyncs
2131 <
2132 <    /**
2133 <     * thenRunAsync result completes normally after normal completion of source
2134 <     */
2135 <    public void testThenRunAsync() {
2136 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2137 <        Noop r = new Noop();
2138 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2139 <        f.complete(null);
2140 <        checkCompletedNormally(g, null);
2141 <
2142 <        // reordered version
2143 <        f = new CompletableFuture<>();
2144 <        f.complete(null);
2145 <        r = new Noop();
2146 <        g = f.thenRunAsync(r);
2147 <        checkCompletedNormally(g, null);
2148 <    }
2149 <
2150 <    /**
2151 <     * thenRunAsync result completes exceptionally after exceptional
2152 <     * completion of source
2153 <     */
2154 <    public void testThenRunAsync2() {
2155 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2156 <        Noop r = new Noop();
2157 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2158 <        f.completeExceptionally(new CFException());
2159 <        try {
2160 <            g.join();
2161 <            shouldThrow();
2162 <        } catch (CompletionException success) {}
2163 <        checkCompletedWithWrappedCFException(g);
2164 <    }
2165 <
2166 <    /**
2167 <     * thenRunAsync result completes exceptionally if action does
2168 <     */
2169 <    public void testThenRunAsync3() {
2170 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2171 <        FailingNoop r = new FailingNoop();
2172 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2173 <        f.complete(null);
2174 <        checkCompletedWithWrappedCFException(g);
2175 <    }
2176 <
2177 <    /**
2178 <     * thenRunAsync result completes exceptionally if source cancelled
2179 <     */
2180 <    public void testThenRunAsync4() {
2181 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2182 <        Noop r = new Noop();
2183 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2184 <        assertTrue(f.cancel(true));
2185 <        checkCompletedWithWrappedCancellationException(g);
2186 <    }
2187 <
2188 <    /**
2189 <     * thenApplyAsync result completes normally after normal completion of source
2190 <     */
2191 <    public void testThenApplyAsync() {
2192 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2193 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2194 <        f.complete(one);
2195 <        checkCompletedNormally(g, two);
2196 <    }
2197 <
2198 <    /**
2199 <     * thenApplyAsync result completes exceptionally after exceptional
2200 <     * completion of source
2201 <     */
2202 <    public void testThenApplyAsync2() {
2203 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2204 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2205 <        f.completeExceptionally(new CFException());
2206 <        checkCompletedWithWrappedCFException(g);
2207 <    }
2208 <
2209 <    /**
2210 <     * thenApplyAsync result completes exceptionally if action does
2211 <     */
2212 <    public void testThenApplyAsync3() {
2213 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2214 <        FailingFunction r = new FailingFunction();
2215 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2216 <        f.complete(null);
2217 <        checkCompletedWithWrappedCFException(g);
2218 <    }
2219 <
2220 <    /**
2221 <     * thenApplyAsync result completes exceptionally if source cancelled
2222 <     */
2223 <    public void testThenApplyAsync4() {
2224 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2225 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2226 <        assertTrue(f.cancel(true));
2227 <        checkCompletedWithWrappedCancellationException(g);
2228 <    }
2229 <
2230 <    /**
2231 <     * thenAcceptAsync result completes normally after normal
2232 <     * completion of source
2233 <     */
2234 <    public void testThenAcceptAsync() {
2235 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2236 <        IncAction r = new IncAction();
2237 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2238 <        f.complete(one);
2239 <        checkCompletedNormally(g, null);
2240 <        assertEquals(r.value, (Integer) 2);
2241 <    }
2242 <
2243 <    /**
2244 <     * thenAcceptAsync result completes exceptionally after exceptional
2245 <     * completion of source
2246 <     */
2247 <    public void testThenAcceptAsync2() {
2248 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2249 <        IncAction r = new IncAction();
2250 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2251 <        f.completeExceptionally(new CFException());
2252 <        checkCompletedWithWrappedCFException(g);
2253 <    }
2254 <
2255 <    /**
2256 <     * thenAcceptAsync result completes exceptionally if action does
2257 <     */
2258 <    public void testThenAcceptAsync3() {
2259 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2260 <        FailingConsumer r = new FailingConsumer();
2261 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2262 <        f.complete(null);
2263 <        checkCompletedWithWrappedCFException(g);
2264 <    }
2265 <
2266 <    /**
2267 <     * thenAcceptAsync result completes exceptionally if source cancelled
2268 <     */
2269 <    public void testThenAcceptAsync4() {
2270 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2271 <        IncAction r = new IncAction();
2272 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2273 <        assertTrue(f.cancel(true));
2274 <        checkCompletedWithWrappedCancellationException(g);
2275 <    }
2276 <
2277 <    /**
2278 <     * applyToEitherAsync result completes normally after normal
2279 <     * completion of sources
2280 <     */
2281 <    public void testApplyToEitherAsync() {
2282 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2283 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2284 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2285 <        f.complete(one);
2286 <        checkCompletedNormally(g, two);
2287 <
2288 <        f = new CompletableFuture<>();
2289 <        f.complete(one);
2290 <        f2 = new CompletableFuture<>();
2291 <        g = f.applyToEitherAsync(f2, inc);
2292 <        checkCompletedNormally(g, two);
2293 <    }
2294 <
2295 <    /**
2296 <     * applyToEitherAsync result completes exceptionally after exceptional
2297 <     * completion of source
2298 <     */
2299 <    public void testApplyToEitherAsync2() {
2300 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2301 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2302 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2303 <        f.completeExceptionally(new CFException());
2304 <        checkCompletedWithWrappedCFException(g);
2305 <
2306 <        f = new CompletableFuture<>();
2307 <        f2 = new CompletableFuture<>();
2308 <        f2.completeExceptionally(new CFException());
2309 <        g = f.applyToEitherAsync(f2, inc);
2310 <        f.complete(one);
2311 <        checkCompletedWithWrappedCFException(g);
2312 <    }
2313 <
2314 <    /**
2315 <     * applyToEitherAsync result completes exceptionally if action does
2316 <     */
2317 <    public void testApplyToEitherAsync3() {
2318 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2319 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2320 <        FailingFunction r = new FailingFunction();
2321 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
2322 <        f.complete(one);
2323 <        checkCompletedWithWrappedCFException(g);
2324 <    }
2325 <
2326 <    /**
2327 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2328 <     */
2329 <    public void testApplyToEitherAsync4() {
2330 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2331 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2332 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2333 <        assertTrue(f.cancel(true));
2334 <        checkCompletedWithWrappedCancellationException(g);
2335 <
2336 <        f = new CompletableFuture<>();
2337 <        f2 = new CompletableFuture<>();
2338 <        assertTrue(f2.cancel(true));
2339 <        g = f.applyToEitherAsync(f2, inc);
2340 <        checkCompletedWithWrappedCancellationException(g);
2341 <    }
2342 <
2343 <    /**
2344 <     * acceptEitherAsync result completes normally after normal
2345 <     * completion of sources
2346 <     */
2347 <    public void testAcceptEitherAsync() {
2348 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2349 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2350 <        IncAction r = new IncAction();
2351 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2352 <        f.complete(one);
2353 <        checkCompletedNormally(g, null);
2354 <        assertEquals(r.value, (Integer) 2);
2355 <
2356 <        r = new IncAction();
2357 <        f = new CompletableFuture<>();
2358 <        f.complete(one);
2359 <        f2 = new CompletableFuture<>();
2360 <        g = f.acceptEitherAsync(f2, r);
2361 <        checkCompletedNormally(g, null);
2362 <        assertEquals(r.value, (Integer) 2);
2363 <    }
2364 <
2365 <    /**
2366 <     * acceptEitherAsync result completes exceptionally after exceptional
2367 <     * completion of source
2368 <     */
2369 <    public void testAcceptEitherAsync2() {
2370 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2371 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2372 <        IncAction r = new IncAction();
2373 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2374 <        f.completeExceptionally(new CFException());
2375 <        checkCompletedWithWrappedCFException(g);
2376 <
2377 <        r = new IncAction();
2378 <        f = new CompletableFuture<>();
2379 <        f2 = new CompletableFuture<>();
2380 <        f2.completeExceptionally(new CFException());
2381 <        g = f.acceptEitherAsync(f2, r);
2382 <        f.complete(one);
2383 <        checkCompletedWithWrappedCFException(g);
2384 <    }
2385 <
2386 <    /**
2387 <     * acceptEitherAsync result completes exceptionally if action does
2388 <     */
2389 <    public void testAcceptEitherAsync3() {
2390 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2391 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2392 <        FailingConsumer r = new FailingConsumer();
2393 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2394 <        f.complete(one);
2395 <        checkCompletedWithWrappedCFException(g);
2396 <    }
2397 <
2398 <    /**
2399 <     * acceptEitherAsync result completes exceptionally if either
2400 <     * source cancelled
2401 <     */
2402 <    public void testAcceptEitherAsync4() {
2403 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2404 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2405 <        IncAction r = new IncAction();
2406 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2407 <        assertTrue(f.cancel(true));
2408 <        checkCompletedWithWrappedCancellationException(g);
2409 <
2410 <        r = new IncAction();
2411 <        f = new CompletableFuture<>();
2412 <        f2 = new CompletableFuture<>();
2413 <        assertTrue(f2.cancel(true));
2414 <        g = f.acceptEitherAsync(f2, r);
2415 <        checkCompletedWithWrappedCancellationException(g);
2416 <    }
2417 <
2418 <    /**
2419 <     * runAfterEitherAsync result completes normally after normal
2420 <     * completion of sources
2421 <     */
2422 <    public void testRunAfterEitherAsync() {
2423 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2424 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2425 <        Noop r = new Noop();
2426 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2427 <        f.complete(one);
2428 <        checkCompletedNormally(g, null);
2429 <        assertTrue(r.ran);
2430 <
2431 <        r = new Noop();
2432 <        f = new CompletableFuture<>();
2433 <        f.complete(one);
2434 <        f2 = new CompletableFuture<>();
2435 <        g = f.runAfterEitherAsync(f2, r);
2436 <        checkCompletedNormally(g, null);
2437 <        assertTrue(r.ran);
2438 <    }
2439 <
2440 <    /**
2441 <     * runAfterEitherAsync result completes exceptionally after exceptional
2442 <     * completion of source
2443 <     */
2444 <    public void testRunAfterEitherAsync2() {
2445 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2446 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2447 <        Noop r = new Noop();
2448 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2449 <        f.completeExceptionally(new CFException());
2450 <        checkCompletedWithWrappedCFException(g);
2451 <
2452 <        r = new Noop();
2453 <        f = new CompletableFuture<>();
2454 <        f2 = new CompletableFuture<>();
2455 <        f2.completeExceptionally(new CFException());
2456 <        g = f.runAfterEitherAsync(f2, r);
2457 <        f.complete(one);
2458 <        checkCompletedWithWrappedCFException(g);
2459 <    }
2460 <
2461 <    /**
2462 <     * runAfterEitherAsync result completes exceptionally if action does
2463 <     */
2464 <    public void testRunAfterEitherAsync3() {
2465 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2466 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2467 <        FailingNoop r = new FailingNoop();
2468 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2469 <        f.complete(one);
2470 <        checkCompletedWithWrappedCFException(g);
2471 <    }
2472 <
2473 <    /**
2474 <     * runAfterEitherAsync result completes exceptionally if either
2475 <     * source cancelled
2476 <     */
2477 <    public void testRunAfterEitherAsync4() {
2478 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2479 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2480 <        Noop r = new Noop();
2481 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2482 <        assertTrue(f.cancel(true));
2483 <        checkCompletedWithWrappedCancellationException(g);
2484 <
2485 <        r = new Noop();
2486 <        f = new CompletableFuture<>();
2487 <        f2 = new CompletableFuture<>();
2488 <        assertTrue(f2.cancel(true));
2489 <        g = f.runAfterEitherAsync(f2, r);
2490 <        checkCompletedWithWrappedCancellationException(g);
2491 <    }
2492 <
2493 <    /**
2494 <     * thenComposeAsync result completes normally after normal
2495 <     * completion of source
2496 <     */
2497 <    public void testThenComposeAsync() {
2498 <        CompletableFuture<Integer> f, g;
2499 <        CompletableFutureInc r;
2500 <
2501 <        f = new CompletableFuture<>();
2502 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2503 <        f.complete(one);
2504 <        checkCompletedNormally(g, two);
2505 <
2506 <        f = new CompletableFuture<>();
2507 <        f.complete(one);
2508 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2509 <        checkCompletedNormally(g, two);
2510 <    }
2511 <
2512 <    /**
2513 <     * thenComposeAsync result completes exceptionally after
2514 <     * exceptional completion of source
2515 <     */
2516 <    public void testThenComposeAsync2() {
2517 <        CompletableFuture<Integer> f, g;
2518 <        CompletableFutureInc r;
2519 <
2520 <        f = new CompletableFuture<>();
2521 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2522 <        f.completeExceptionally(new CFException());
2523 <        checkCompletedWithWrappedCFException(g);
2524 <        assertFalse(r.ran);
2525 <
2526 <        f = new CompletableFuture<>();
2527 <        f.completeExceptionally(new CFException());
2528 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2529 <        checkCompletedWithWrappedCFException(g);
2530 <        assertFalse(r.ran);
2531 <    }
2532 <
2533 <    /**
2534 <     * thenComposeAsync result completes exceptionally if action does
2535 <     */
2536 <    public void testThenComposeAsync3() {
2537 <        CompletableFuture<Integer> f, g;
2538 <        FailingCompletableFutureFunction r;
2539 <
2540 <        f = new CompletableFuture<>();
2541 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2542 <        f.complete(one);
2543 <        checkCompletedWithWrappedCFException(g);
2544 <
2545 <        f = new CompletableFuture<>();
2546 <        f.complete(one);
2547 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2548 <        checkCompletedWithWrappedCFException(g);
2549 <    }
2550 <
2551 <    /**
2552 <     * thenComposeAsync result completes exceptionally if source cancelled
2553 <     */
2554 <    public void testThenComposeAsync4() {
2555 <        CompletableFuture<Integer> f, g;
2556 <        CompletableFutureInc r;
2557 <
2558 <        f = new CompletableFuture<>();
2559 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2560 <        assertTrue(f.cancel(true));
2561 <        checkCompletedWithWrappedCancellationException(g);
2562 <
2563 <        f = new CompletableFuture<>();
2564 <        assertTrue(f.cancel(true));
2565 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2566 <        checkCompletedWithWrappedCancellationException(g);
2567 <    }
2568 <
2569 <    // async with explicit executors
2570 <
2571 <    /**
2572 <     * thenRunAsync result completes normally after normal completion of source
2573 <     */
2574 <    public void testThenRunAsyncE() {
2575 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2576 <        Noop r = new Noop();
2577 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2578 <        f.complete(null);
2579 <        checkCompletedNormally(g, null);
2580 <
2581 <        // reordered version
2582 <        f = new CompletableFuture<>();
2583 <        f.complete(null);
2584 <        r = new Noop();
2585 <        g = f.thenRunAsync(r, new ThreadExecutor());
2586 <        checkCompletedNormally(g, null);
2587 <    }
2588 <
2589 <    /**
2590 <     * thenRunAsync result completes exceptionally after exceptional
2591 <     * completion of source
2592 <     */
2593 <    public void testThenRunAsync2E() {
2594 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2595 <        Noop r = new Noop();
2596 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2597 <        f.completeExceptionally(new CFException());
2598 <        try {
2599 <            g.join();
2600 <            shouldThrow();
2601 <        } catch (CompletionException success) {}
2602 <        checkCompletedWithWrappedCFException(g);
2603 <    }
2604 <
2605 <    /**
2606 <     * thenRunAsync result completes exceptionally if action does
2607 <     */
2608 <    public void testThenRunAsync3E() {
2609 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2610 <        FailingNoop r = new FailingNoop();
2611 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2612 <        f.complete(null);
2613 <        checkCompletedWithWrappedCFException(g);
2614 <    }
2615 <
2616 <    /**
2617 <     * thenRunAsync result completes exceptionally if source cancelled
2618 <     */
2619 <    public void testThenRunAsync4E() {
2620 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2621 <        Noop r = new Noop();
2622 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2623 <        assertTrue(f.cancel(true));
2624 <        checkCompletedWithWrappedCancellationException(g);
2625 <    }
2626 <
2627 <    /**
2628 <     * thenApplyAsync result completes normally after normal completion of source
2629 <     */
2630 <    public void testThenApplyAsyncE() {
2631 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2632 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2633 <        f.complete(one);
2634 <        checkCompletedNormally(g, two);
2635 <    }
2636 <
2637 <    /**
2638 <     * thenApplyAsync result completes exceptionally after exceptional
2639 <     * completion of source
2640 <     */
2641 <    public void testThenApplyAsync2E() {
2642 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2643 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2644 <        f.completeExceptionally(new CFException());
2645 <        checkCompletedWithWrappedCFException(g);
2646 <    }
2647 <
2648 <    /**
2649 <     * thenApplyAsync result completes exceptionally if action does
2650 <     */
2651 <    public void testThenApplyAsync3E() {
2652 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2653 <        FailingFunction r = new FailingFunction();
2654 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2655 <        f.complete(null);
2656 <        checkCompletedWithWrappedCFException(g);
2657 <    }
2658 <
2659 <    /**
2660 <     * thenApplyAsync result completes exceptionally if source cancelled
2661 <     */
2662 <    public void testThenApplyAsync4E() {
2663 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2664 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2665 <        assertTrue(f.cancel(true));
2666 <        checkCompletedWithWrappedCancellationException(g);
2667 <    }
2668 <
2669 <    /**
2670 <     * thenAcceptAsync result completes normally after normal
2671 <     * completion of source
2672 <     */
2673 <    public void testThenAcceptAsyncE() {
2674 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2675 <        IncAction r = new IncAction();
2676 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2677 <        f.complete(one);
2678 <        checkCompletedNormally(g, null);
2679 <        assertEquals(r.value, (Integer) 2);
2680 <    }
2681 <
2682 <    /**
2683 <     * thenAcceptAsync result completes exceptionally after exceptional
2684 <     * completion of source
2685 <     */
2686 <    public void testThenAcceptAsync2E() {
2687 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2688 <        IncAction r = new IncAction();
2689 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2690 <        f.completeExceptionally(new CFException());
2691 <        checkCompletedWithWrappedCFException(g);
2692 <    }
2693 <
2694 <    /**
2695 <     * thenAcceptAsync result completes exceptionally if action does
2696 <     */
2697 <    public void testThenAcceptAsync3E() {
2698 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2699 <        FailingConsumer r = new FailingConsumer();
2700 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2701 <        f.complete(null);
2702 <        checkCompletedWithWrappedCFException(g);
2703 <    }
2704 <
2705 <    /**
2706 <     * thenAcceptAsync result completes exceptionally if source cancelled
2707 <     */
2708 <    public void testThenAcceptAsync4E() {
2709 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2710 <        IncAction r = new IncAction();
2711 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2712 <        assertTrue(f.cancel(true));
2713 <        checkCompletedWithWrappedCancellationException(g);
2714 <    }
2715 <
2716 <    /**
2717 <     * applyToEitherAsync result completes normally after normal
2718 <     * completion of sources
2719 <     */
2720 <    public void testApplyToEitherAsyncE() {
2721 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2722 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2723 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2724 <        f.complete(one);
2725 <        checkCompletedNormally(g, two);
2726 <
2727 <        f = new CompletableFuture<>();
2728 <        f.complete(one);
2729 <        f2 = new CompletableFuture<>();
2730 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2731 <        checkCompletedNormally(g, two);
2732 <    }
2733 <
2734 <    /**
2735 <     * applyToEitherAsync result completes exceptionally after exceptional
2736 <     * completion of source
2737 <     */
2738 <    public void testApplyToEitherAsync2E() {
2739 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2740 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2741 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2742 <        f.completeExceptionally(new CFException());
2743 <        checkCompletedWithWrappedCFException(g);
2744 <
2745 <        f = new CompletableFuture<>();
2746 <        f2 = new CompletableFuture<>();
2747 <        f2.completeExceptionally(new CFException());
2748 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2749 <        f.complete(one);
2750 <        checkCompletedWithWrappedCFException(g);
2751 <    }
2752 <
2753 <    /**
2754 <     * applyToEitherAsync result completes exceptionally if action does
2755 <     */
2756 <    public void testApplyToEitherAsync3E() {
2757 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2758 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2759 <        FailingFunction r = new FailingFunction();
2760 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
2761 <        f.complete(one);
2762 <        checkCompletedWithWrappedCFException(g);
2763 <    }
2764 <
2765 <    /**
2766 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2767 <     */
2768 <    public void testApplyToEitherAsync4E() {
2769 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2770 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2771 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2772 <        assertTrue(f.cancel(true));
2773 <        checkCompletedWithWrappedCancellationException(g);
2774 <
2775 <        f = new CompletableFuture<>();
2776 <        f2 = new CompletableFuture<>();
2777 <        assertTrue(f2.cancel(true));
2778 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2779 <        checkCompletedWithWrappedCancellationException(g);
2780 <    }
2781 <
2782 <    /**
2783 <     * acceptEitherAsync result completes normally after normal
2784 <     * completion of sources
2785 <     */
2786 <    public void testAcceptEitherAsyncE() {
2787 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2788 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2789 <        IncAction r = new IncAction();
2790 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2791 <        f.complete(one);
2792 <        checkCompletedNormally(g, null);
2793 <        assertEquals(r.value, (Integer) 2);
2794 <
2795 <        r = new IncAction();
2796 <        f = new CompletableFuture<>();
2797 <        f.complete(one);
2798 <        f2 = new CompletableFuture<>();
2799 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2800 <        checkCompletedNormally(g, null);
2801 <        assertEquals(r.value, (Integer) 2);
2802 <    }
2803 <
2804 <    /**
2805 <     * acceptEitherAsync result completes exceptionally after exceptional
2806 <     * completion of source
2807 <     */
2808 <    public void testAcceptEitherAsync2E() {
2809 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2810 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2811 <        IncAction r = new IncAction();
2812 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2813 <        f.completeExceptionally(new CFException());
2814 <        checkCompletedWithWrappedCFException(g);
2815 <
2816 <        r = new IncAction();
2817 <        f = new CompletableFuture<>();
2818 <        f2 = new CompletableFuture<>();
2819 <        f2.completeExceptionally(new CFException());
2820 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2821 <        f.complete(one);
2822 <        checkCompletedWithWrappedCFException(g);
2823 <    }
2824 <
2825 <    /**
2826 <     * acceptEitherAsync result completes exceptionally if action does
2827 <     */
2828 <    public void testAcceptEitherAsync3E() {
2829 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2830 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2831 <        FailingConsumer r = new FailingConsumer();
2832 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2833 <        f.complete(one);
2834 <        checkCompletedWithWrappedCFException(g);
2835 <    }
2836 <
2837 <    /**
2838 <     * acceptEitherAsync result completes exceptionally if either
2839 <     * source cancelled
2840 <     */
2841 <    public void testAcceptEitherAsync4E() {
2842 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2843 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2844 <        IncAction r = new IncAction();
2845 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2846 <        assertTrue(f.cancel(true));
2847 <        checkCompletedWithWrappedCancellationException(g);
2848 <
2849 <        r = new IncAction();
2850 <        f = new CompletableFuture<>();
2851 <        f2 = new CompletableFuture<>();
2852 <        assertTrue(f2.cancel(true));
2853 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2854 <        checkCompletedWithWrappedCancellationException(g);
2855 <    }
2856 <
2857 <    /**
2858 <     * runAfterEitherAsync result completes normally after normal
2859 <     * completion of sources
2860 <     */
2861 <    public void testRunAfterEitherAsyncE() {
2862 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2863 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2864 <        Noop r = new Noop();
2865 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2866 <        f.complete(one);
2867 <        checkCompletedNormally(g, null);
2868 <        assertTrue(r.ran);
2869 <
2870 <        r = new Noop();
2871 <        f = new CompletableFuture<>();
2872 <        f.complete(one);
2873 <        f2 = new CompletableFuture<>();
2874 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2875 <        checkCompletedNormally(g, null);
2876 <        assertTrue(r.ran);
2877 <    }
2878 <
2879 <    /**
2880 <     * runAfterEitherAsync result completes exceptionally after exceptional
2881 <     * completion of source
2882 <     */
2883 <    public void testRunAfterEitherAsync2E() {
2884 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2885 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2886 <        Noop r = new Noop();
2887 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2888 <        f.completeExceptionally(new CFException());
2889 <        checkCompletedWithWrappedCFException(g);
2890 <
2891 <        r = new Noop();
2892 <        f = new CompletableFuture<>();
2893 <        f2 = new CompletableFuture<>();
2894 <        f2.completeExceptionally(new CFException());
2895 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2896 <        f.complete(one);
2897 <        checkCompletedWithWrappedCFException(g);
2898 <    }
2899 <
2900 <    /**
2901 <     * runAfterEitherAsync result completes exceptionally if action does
2902 <     */
2903 <    public void testRunAfterEitherAsync3E() {
2904 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2905 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2906 <        FailingNoop r = new FailingNoop();
2907 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2908 <        f.complete(one);
2909 <        checkCompletedWithWrappedCFException(g);
2910 <    }
2911 <
2912 <    /**
2913 <     * runAfterEitherAsync result completes exceptionally if either
2914 <     * source cancelled
2915 <     */
2916 <    public void testRunAfterEitherAsync4E() {
2917 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2918 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2919 <        Noop r = new Noop();
2920 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2921 <        assertTrue(f.cancel(true));
2922 <        checkCompletedWithWrappedCancellationException(g);
2923 <
2924 <        r = new Noop();
2925 <        f = new CompletableFuture<>();
2926 <        f2 = new CompletableFuture<>();
2927 <        assertTrue(f2.cancel(true));
2928 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2929 <        checkCompletedWithWrappedCancellationException(g);
2930 <    }
2931 <
2932 <    /**
2933 <     * thenComposeAsync result completes normally after normal
2934 <     * completion of source
2935 <     */
2936 <    public void testThenComposeAsyncE() {
2937 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2938 <        CompletableFutureInc r = new CompletableFutureInc();
2939 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2940 <        f.complete(one);
2941 <        checkCompletedNormally(g, two);
2942 <    }
2943 <
2944 <    /**
2945 <     * thenComposeAsync result completes exceptionally after
2946 <     * exceptional completion of source
2947 <     */
2948 <    public void testThenComposeAsync2E() {
2949 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2950 <        CompletableFutureInc r = new CompletableFutureInc();
2951 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2952 <        f.completeExceptionally(new CFException());
2953 <        checkCompletedWithWrappedCFException(g);
2954 <    }
2955 <
2956 <    /**
2957 <     * thenComposeAsync result completes exceptionally if action does
2958 <     */
2959 <    public void testThenComposeAsync3E() {
2960 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2961 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2962 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2963 <        f.complete(one);
2964 <        checkCompletedWithWrappedCFException(g);
2965 <    }
2531 >    public void testThenCompose_sourceCancelled() {
2532 >        for (ExecutionMode m : ExecutionMode.values())
2533 >        for (boolean createIncomplete : new boolean[] { true, false })
2534 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2535 >    {
2536 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2537 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2538 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2539 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2540 >        if (createIncomplete) {
2541 >            checkIncomplete(g);
2542 >            assertTrue(f.cancel(mayInterruptIfRunning));
2543 >        }
2544  
2967    /**
2968     * thenComposeAsync result completes exceptionally if source cancelled
2969     */
2970    public void testThenComposeAsync4E() {
2971        CompletableFuture<Integer> f = new CompletableFuture<>();
2972        CompletableFutureInc r = new CompletableFutureInc();
2973        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2974        assertTrue(f.cancel(true));
2545          checkCompletedWithWrappedCancellationException(g);
2546 <    }
2546 >        checkCancelled(f);
2547 >    }}
2548  
2549      // other static methods
2550  
# Line 2992 | Line 2563 | public class CompletableFutureTest exten
2563       */
2564      public void testAllOf_normal() throws Exception {
2565          for (int k = 1; k < 20; ++k) {
2566 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2566 >            CompletableFuture<Integer>[] fs
2567 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2568              for (int i = 0; i < k; ++i)
2569                  fs[i] = new CompletableFuture<>();
2570              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
# Line 3006 | Line 2578 | public class CompletableFutureTest exten
2578          }
2579      }
2580  
2581 +    public void testAllOf_backwards() throws Exception {
2582 +        for (int k = 1; k < 20; ++k) {
2583 +            CompletableFuture<Integer>[] fs
2584 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2585 +            for (int i = 0; i < k; ++i)
2586 +                fs[i] = new CompletableFuture<>();
2587 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2588 +            for (int i = k - 1; i >= 0; i--) {
2589 +                checkIncomplete(f);
2590 +                checkIncomplete(CompletableFuture.allOf(fs));
2591 +                fs[i].complete(one);
2592 +            }
2593 +            checkCompletedNormally(f, null);
2594 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
2595 +        }
2596 +    }
2597 +
2598      /**
2599       * anyOf(no component futures) returns an incomplete future
2600       */
# Line 3064 | Line 2653 | public class CompletableFutureTest exten
2653          Runnable[] throwingActions = {
2654              () -> CompletableFuture.supplyAsync(null),
2655              () -> CompletableFuture.supplyAsync(null, exec),
2656 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
2656 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
2657  
2658              () -> CompletableFuture.runAsync(null),
2659              () -> CompletableFuture.runAsync(null, exec),
# Line 3137 | Line 2726 | public class CompletableFutureTest exten
2726  
2727              () -> f.thenCompose(null),
2728              () -> f.thenComposeAsync(null),
2729 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2729 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2730              () -> f.thenComposeAsync(null, exec),
2731  
2732              () -> f.exceptionally(null),
# Line 3173 | Line 2762 | public class CompletableFutureTest exten
2762       * whenComplete action executes on normal completion, propagating
2763       * source result.
2764       */
2765 <    public void testWhenComplete1() {
2766 <        final AtomicInteger a = new AtomicInteger();
2767 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2768 <        CompletableFuture<Integer> g =
2769 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
2770 <        f.complete(three);
2771 <        checkCompletedNormally(f, three);
2772 <        checkCompletedNormally(g, three);
2773 <        assertEquals(a.get(), 1);
2774 <    }
2775 <
2776 <    /**
2777 <     * whenComplete action executes on exceptional completion, propagating
2778 <     * source result.
2779 <     */
2780 <    public void testWhenComplete2() {
3192 <        final AtomicInteger a = new AtomicInteger();
3193 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3194 <        CompletableFuture<Integer> g =
3195 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3196 <        f.completeExceptionally(new CFException());
3197 <        assertTrue(f.isCompletedExceptionally());
3198 <        assertTrue(g.isCompletedExceptionally());
3199 <        assertEquals(a.get(), 1);
3200 <    }
3201 <
3202 <    /**
3203 <     * If a whenComplete action throws an exception when triggered by
3204 <     * a normal completion, it completes exceptionally
3205 <     */
3206 <    public void testWhenComplete3() {
3207 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3208 <        CompletableFuture<Integer> g =
3209 <            f.whenComplete((Integer x, Throwable t) ->
3210 <                           { throw new CFException(); } );
3211 <        f.complete(three);
3212 <        checkCompletedNormally(f, three);
3213 <        assertTrue(g.isCompletedExceptionally());
3214 <        checkCompletedWithWrappedCFException(g);
3215 <    }
3216 <
3217 <    /**
3218 <     * whenCompleteAsync action executes on normal completion, propagating
3219 <     * source result.
3220 <     */
3221 <    public void testWhenCompleteAsync1() {
3222 <        final AtomicInteger a = new AtomicInteger();
3223 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3224 <        CompletableFuture<Integer> g =
3225 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3226 <        f.complete(three);
3227 <        checkCompletedNormally(f, three);
3228 <        checkCompletedNormally(g, three);
3229 <        assertEquals(a.get(), 1);
3230 <    }
3231 <
3232 <    /**
3233 <     * whenCompleteAsync action executes on exceptional completion, propagating
3234 <     * source result.
3235 <     */
3236 <    public void testWhenCompleteAsync2() {
3237 <        final AtomicInteger a = new AtomicInteger();
3238 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3239 <        CompletableFuture<Integer> g =
3240 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3241 <        f.completeExceptionally(new CFException());
3242 <        checkCompletedWithWrappedCFException(f);
3243 <        checkCompletedWithWrappedCFException(g);
3244 <    }
2765 >    public void testWhenComplete_normalCompletion1() {
2766 >        for (ExecutionMode m : ExecutionMode.values())
2767 >        for (boolean createIncomplete : new boolean[] { true, false })
2768 >        for (Integer v1 : new Integer[] { 1, null })
2769 >    {
2770 >        final AtomicInteger a = new AtomicInteger(0);
2771 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2772 >        if (!createIncomplete) f.complete(v1);
2773 >        final CompletableFuture<Integer> g = m.whenComplete
2774 >            (f,
2775 >             (Integer x, Throwable t) -> {
2776 >                threadAssertSame(x, v1);
2777 >                threadAssertNull(t);
2778 >                a.getAndIncrement();
2779 >            });
2780 >        if (createIncomplete) f.complete(v1);
2781  
2782 <    /**
2783 <     * If a whenCompleteAsync action throws an exception when
2784 <     * triggered by a normal completion, it completes exceptionally
2785 <     */
3250 <    public void testWhenCompleteAsync3() {
3251 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3252 <        CompletableFuture<Integer> g =
3253 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3254 <                           { throw new CFException(); } );
3255 <        f.complete(three);
3256 <        checkCompletedNormally(f, three);
3257 <        checkCompletedWithWrappedCFException(g);
3258 <    }
2782 >        checkCompletedNormally(g, v1);
2783 >        checkCompletedNormally(f, v1);
2784 >        assertEquals(1, a.get());
2785 >    }}
2786  
2787      /**
2788 <     * whenCompleteAsync action executes on normal completion, propagating
2788 >     * whenComplete action executes on exceptional completion, propagating
2789       * source result.
2790       */
2791 <    public void testWhenCompleteAsync1e() {
2792 <        final AtomicInteger a = new AtomicInteger();
2793 <        ThreadExecutor exec = new ThreadExecutor();
2794 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2795 <        CompletableFuture<Integer> g =
2796 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
2797 <                                exec);
2798 <        f.complete(three);
2799 <        checkCompletedNormally(f, three);
2800 <        checkCompletedNormally(g, three);
2801 <        assertEquals(a.get(), 1);
2802 <    }
2791 >    public void testWhenComplete_exceptionalCompletion() {
2792 >        for (ExecutionMode m : ExecutionMode.values())
2793 >        for (boolean createIncomplete : new boolean[] { true, false })
2794 >        for (Integer v1 : new Integer[] { 1, null })
2795 >    {
2796 >        final AtomicInteger a = new AtomicInteger(0);
2797 >        final CFException ex = new CFException();
2798 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2799 >        if (!createIncomplete) f.completeExceptionally(ex);
2800 >        final CompletableFuture<Integer> g = m.whenComplete
2801 >            (f,
2802 >             (Integer x, Throwable t) -> {
2803 >                threadAssertNull(x);
2804 >                threadAssertSame(t, ex);
2805 >                a.getAndIncrement();
2806 >            });
2807 >        if (createIncomplete) f.completeExceptionally(ex);
2808 >        checkCompletedWithWrappedCFException(f, ex);
2809 >        checkCompletedWithWrappedCFException(g, ex);
2810 >        assertEquals(1, a.get());
2811 >    }}
2812  
2813      /**
2814 <     * whenCompleteAsync action executes on exceptional completion, propagating
2815 <     * source result.
2814 >     * whenComplete action executes on cancelled source, propagating
2815 >     * CancellationException.
2816       */
2817 <    public void testWhenCompleteAsync2e() {
2818 <        final AtomicInteger a = new AtomicInteger();
2819 <        ThreadExecutor exec = new ThreadExecutor();
2820 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2821 <        CompletableFuture<Integer> g =
2822 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
2823 <                                exec);
2824 <        f.completeExceptionally(new CFException());
2825 <        checkCompletedWithWrappedCFException(f);
2826 <        checkCompletedWithWrappedCFException(g);
2827 <    }
2817 >    public void testWhenComplete_sourceCancelled() {
2818 >        for (ExecutionMode m : ExecutionMode.values())
2819 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2820 >        for (boolean createIncomplete : new boolean[] { true, false })
2821 >    {
2822 >        final AtomicInteger a = new AtomicInteger(0);
2823 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2824 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2825 >        final CompletableFuture<Integer> g = m.whenComplete
2826 >            (f,
2827 >             (Integer x, Throwable t) -> {
2828 >                threadAssertNull(x);
2829 >                threadAssertTrue(t instanceof CancellationException);
2830 >                a.getAndIncrement();
2831 >            });
2832 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2833  
2834 <    /**
2835 <     * If a whenCompleteAsync action throws an exception when triggered
2836 <     * by a normal completion, it completes exceptionally
2837 <     */
2838 <    public void testWhenCompleteAsync3e() {
3298 <        ThreadExecutor exec = new ThreadExecutor();
3299 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3300 <        CompletableFuture<Integer> g =
3301 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3302 <                                { throw new CFException(); },
3303 <                                exec);
3304 <        f.complete(three);
3305 <        checkCompletedNormally(f, three);
3306 <        checkCompletedWithWrappedCFException(g);
3307 <    }
2834 >        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
2835 >        checkCompletedWithWrappedCancellationException(g);
2836 >        checkCancelled(f);
2837 >        assertEquals(1, a.get());
2838 >    }}
2839  
2840      /**
2841 <     * handleAsync action completes normally with function value on
2842 <     * either normal or exceptional completion of source
2841 >     * If a whenComplete action throws an exception when triggered by
2842 >     * a normal completion, it completes exceptionally
2843       */
2844 <    public void testHandleAsync() {
2845 <        CompletableFuture<Integer> f, g;
2846 <        IntegerHandler r;
2847 <
2848 <        f = new CompletableFuture<>();
2849 <        g = f.handleAsync(r = new IntegerHandler());
2850 <        assertFalse(r.ran);
2851 <        f.completeExceptionally(new CFException());
2852 <        checkCompletedWithWrappedCFException(f);
2853 <        checkCompletedNormally(g, three);
2854 <        assertTrue(r.ran);
2855 <
2856 <        f = new CompletableFuture<>();
2857 <        g = f.handleAsync(r = new IntegerHandler());
2858 <        assertFalse(r.ran);
2859 <        f.completeExceptionally(new CFException());
2860 <        checkCompletedWithWrappedCFException(f);
2861 <        checkCompletedNormally(g, three);
2862 <        assertTrue(r.ran);
2863 <
2864 <        f = new CompletableFuture<>();
2865 <        g = f.handleAsync(r = new IntegerHandler());
3335 <        assertFalse(r.ran);
3336 <        f.complete(one);
3337 <        checkCompletedNormally(f, one);
3338 <        checkCompletedNormally(g, two);
3339 <        assertTrue(r.ran);
3340 <
3341 <        f = new CompletableFuture<>();
3342 <        g = f.handleAsync(r = new IntegerHandler());
3343 <        assertFalse(r.ran);
3344 <        f.complete(one);
3345 <        checkCompletedNormally(f, one);
3346 <        checkCompletedNormally(g, two);
3347 <        assertTrue(r.ran);
3348 <    }
2844 >    public void testWhenComplete_actionFailed() {
2845 >        for (boolean createIncomplete : new boolean[] { true, false })
2846 >        for (ExecutionMode m : ExecutionMode.values())
2847 >        for (Integer v1 : new Integer[] { 1, null })
2848 >    {
2849 >        final AtomicInteger a = new AtomicInteger(0);
2850 >        final CFException ex = new CFException();
2851 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2852 >        if (!createIncomplete) f.complete(v1);
2853 >        final CompletableFuture<Integer> g = m.whenComplete
2854 >            (f,
2855 >             (Integer x, Throwable t) -> {
2856 >                threadAssertSame(x, v1);
2857 >                threadAssertNull(t);
2858 >                a.getAndIncrement();
2859 >                throw ex;
2860 >            });
2861 >        if (createIncomplete) f.complete(v1);
2862 >        checkCompletedNormally(f, v1);
2863 >        checkCompletedWithWrappedCFException(g, ex);
2864 >        assertEquals(1, a.get());
2865 >    }}
2866  
2867      /**
2868 <     * handleAsync action with Executor completes normally with
2869 <     * function value on either normal or exceptional completion of
2870 <     * source
2868 >     * If a whenComplete action throws an exception when triggered by
2869 >     * a source completion that also throws an exception, the source
2870 >     * exception takes precedence.
2871       */
2872 <    public void testHandleAsync2() {
2873 <        CompletableFuture<Integer> f, g;
2874 <        ThreadExecutor exec = new ThreadExecutor();
2875 <        IntegerHandler r;
2876 <
2877 <        f = new CompletableFuture<>();
2878 <        g = f.handleAsync(r = new IntegerHandler(), exec);
2879 <        assertFalse(r.ran);
2880 <        f.completeExceptionally(new CFException());
2881 <        checkCompletedWithWrappedCFException(f);
2882 <        checkCompletedNormally(g, three);
2883 <        assertTrue(r.ran);
2884 <
2885 <        f = new CompletableFuture<>();
2886 <        g = f.handleAsync(r = new IntegerHandler(), exec);
2887 <        assertFalse(r.ran);
2888 <        f.completeExceptionally(new CFException());
2889 <        checkCompletedWithWrappedCFException(f);
2890 <        checkCompletedNormally(g, three);
2891 <        assertTrue(r.ran);
2892 <
2893 <        f = new CompletableFuture<>();
2894 <        g = f.handleAsync(r = new IntegerHandler(), exec);
2895 <        assertFalse(r.ran);
2896 <        f.complete(one);
3380 <        checkCompletedNormally(f, one);
3381 <        checkCompletedNormally(g, two);
3382 <        assertTrue(r.ran);
3383 <
3384 <        f = new CompletableFuture<>();
3385 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3386 <        assertFalse(r.ran);
3387 <        f.complete(one);
3388 <        checkCompletedNormally(f, one);
3389 <        checkCompletedNormally(g, two);
3390 <        assertTrue(r.ran);
3391 <    }
2872 >    public void testWhenComplete_actionFailedSourceFailed() {
2873 >        for (boolean createIncomplete : new boolean[] { true, false })
2874 >        for (ExecutionMode m : ExecutionMode.values())
2875 >        for (Integer v1 : new Integer[] { 1, null })
2876 >    {
2877 >        final AtomicInteger a = new AtomicInteger(0);
2878 >        final CFException ex1 = new CFException();
2879 >        final CFException ex2 = new CFException();
2880 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2881 >
2882 >        if (!createIncomplete) f.completeExceptionally(ex1);
2883 >        final CompletableFuture<Integer> g = m.whenComplete
2884 >            (f,
2885 >             (Integer x, Throwable t) -> {
2886 >                threadAssertSame(t, ex1);
2887 >                threadAssertNull(x);
2888 >                a.getAndIncrement();
2889 >                throw ex2;
2890 >            });
2891 >        if (createIncomplete) f.completeExceptionally(ex1);
2892 >
2893 >        checkCompletedWithWrappedCFException(f, ex1);
2894 >        checkCompletedWithWrappedCFException(g, ex1);
2895 >        assertEquals(1, a.get());
2896 >    }}
2897  
2898   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines