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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines