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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines