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

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.42 by jsr166, Mon Jun 2 02:19:23 2014 UTC vs.
Revision 1.94 by jsr166, Wed Jun 18 02:37:38 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 <    // A non-commutative function that handles and produces null values as well.
389 <    static Integer subtract(Integer x, Integer y) {
390 <        return (x == null && y == null) ? null :
391 <            ((x == null) ? 42 : x.intValue())
392 <            - ((y == null) ? 99 : y.intValue());
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      // A function that handles and produces null values as well.
# Line 330 | Line 413 | public class CompletableFutureTest exten
413          return (x == null) ? null : x + 1;
414      }
415  
416 <    static final Supplier<Integer> supplyOne =
417 <        () -> Integer.valueOf(1);
418 <    static final Function<Integer, Integer> inc =
419 <        (Integer x) -> Integer.valueOf(x.intValue() + 1);
337 <    static final BiFunction<Integer, Integer, Integer> subtract =
338 <        (Integer x, Integer y) -> subtract(x, y);
339 <    static final class IncAction implements Consumer<Integer> {
340 <        int invocationCount = 0;
341 <        Integer value;
342 <        public boolean ran() { return invocationCount == 1; }
416 >    class NoopConsumer extends CheckedIntegerAction
417 >        implements Consumer<Integer>
418 >    {
419 >        NoopConsumer(ExecutionMode m) { super(m); }
420          public void accept(Integer x) {
421 <            invocationCount++;
422 <            value = inc(x);
421 >            invoked();
422 >            value = x;
423          }
424      }
425 <    static final class IncFunction implements Function<Integer,Integer> {
426 <        int invocationCount = 0;
427 <        Integer value;
428 <        public boolean ran() { return invocationCount == 1; }
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 <            invocationCount++;
431 >            invoked();
432              return value = inc(x);
433          }
434      }
435 <    static final class SubtractAction implements BiConsumer<Integer, Integer> {
436 <        int invocationCount = 0;
437 <        Integer value;
438 <        // Check this action was invoked exactly once when result is computed.
439 <        public boolean ran() { return invocationCount == 1; }
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 <            invocationCount++;
449 >            invoked();
450              value = subtract(x, y);
451          }
452      }
453 <    static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
454 <        int invocationCount = 0;
455 <        Integer value;
456 <        // Check this action was invoked exactly once when result is computed.
457 <        public boolean ran() { return invocationCount == 1; }
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 <            invocationCount++;
459 >            invoked();
460              return value = subtract(x, y);
461          }
462      }
463 <    static final class Noop implements Runnable {
464 <        int invocationCount = 0;
465 <        boolean ran;
463 >
464 >    class Noop extends CheckedAction implements Runnable {
465 >        Noop(ExecutionMode m) { super(m); }
466          public void run() {
467 <            invocationCount++;
382 <            ran = true;
467 >            invoked();
468          }
469      }
470  
471 <    static final class FailingSupplier implements Supplier<Integer> {
472 <        boolean ran;
473 <        public Integer get() { ran = true; throw new CFException(); }
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 FailingConsumer implements Consumer<Integer> {
481 <        boolean ran;
482 <        public void accept(Integer x) { 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 FailingBiConsumer implements BiConsumer<Integer, Integer> {
492 <        boolean ran;
493 <        public void accept(Integer x, Integer y) { 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 FailingFunction implements Function<Integer, Integer> {
503 <        boolean ran;
504 <        public Integer apply(Integer x) { 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 FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
514 <        boolean ran;
515 <        public Integer apply(Integer x, Integer y) { 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 <    static final class FailingNoop implements Runnable {
525 <        boolean ran;
526 <        public void run() { ran = true; throw new CFException(); }
524 >
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 <    static final class CompletableFutureInc
534 <        implements Function<Integer, CompletableFuture<Integer>> {
535 <        boolean ran;
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();
437 <        }
438 <    }
439 <
440 <    static final class ExceptionToInteger implements Function<Throwable, Integer> {
441 <        public Integer apply(Throwable x) { return Integer.valueOf(3); }
442 <    }
443 <
444 <    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
445 <        boolean ran;
446 <        public Integer apply(Integer x, Throwable t) {
447 <            ran = true;
448 <            return (t == null) ? two : three;
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 471 | Line 628 | public class CompletableFutureTest exten
628                   BiFunction<? super T,? super U,? extends V> a) {
629                  return f.thenCombine(g, a);
630              }
631 <            public <T,U> CompletableFuture<U> applyToEither
631 >            public <T> CompletableFuture<Void> runAfterEither
632                  (CompletableFuture<T> f,
633 <                 CompletionStage<? extends T> g,
634 <                 Function<? super T,U> a) {
635 <                return f.applyToEither(g, a);
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,
# Line 483 | Line 640 | public class CompletableFutureTest exten
640                   Consumer<? super T> a) {
641                  return f.acceptEither(g, a);
642              }
643 <            public <T> CompletableFuture<Void> runAfterEither
643 >            public <T,U> CompletableFuture<U> applyToEither
644                  (CompletableFuture<T> f,
645 <                 CompletionStage<?> g,
646 <                 java.lang.Runnable a) {
647 <                return f.runAfterEither(g, a);
645 >                 CompletionStage<? extends T> g,
646 >                 Function<? super T,U> a) {
647 >                return f.applyToEither(g, a);
648 >            }
649 >        },
650 >
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.thenCompose(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.whenComplete(a);
687 >                return f.whenCompleteAsync(a);
688              }
502        },
503
504 //             /** Experimental way to do more testing */
505 //         REVERSE_DEFAULT {
506 //             public <T,U> CompletableFuture<Void> runAfterBoth
507 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
508 //                 return g.runAfterBoth(f, a);
509 //             }
510 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
511 //                 (CompletableFuture<T> f,
512 //                  CompletionStage<? extends U> g,
513 //                  BiConsumer<? super T,? super U> a) {
514 //                 return DEFAULT.thenAcceptBoth(f, g, a);
515 //             }
516 //         },
517
518        DEFAULT_ASYNC {
689              public <T,U> CompletableFuture<Void> runAfterBoth
690                  (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
691                  return f.runAfterBothAsync(g, a);
# Line 532 | Line 702 | public class CompletableFutureTest exten
702                   BiFunction<? super T,? super U,? extends V> a) {
703                  return f.thenCombineAsync(g, a);
704              }
705 <            public <T,U> CompletableFuture<U> applyToEither
705 >            public <T> CompletableFuture<Void> runAfterEither
706                  (CompletableFuture<T> f,
707 <                 CompletionStage<? extends T> g,
708 <                 Function<? super T,U> a) {
709 <                return f.applyToEitherAsync(g, a);
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,
# Line 544 | Line 714 | public class CompletableFutureTest exten
714                   Consumer<? super T> a) {
715                  return f.acceptEitherAsync(g, a);
716              }
717 <            public <T> CompletableFuture<Void> runAfterEither
717 >            public <T,U> CompletableFuture<U> applyToEither
718                  (CompletableFuture<T> f,
719 <                 CompletionStage<?> g,
720 <                 java.lang.Runnable a) {
721 <                return f.runAfterEitherAsync(g, a);
719 >                 CompletionStage<? extends T> g,
720 >                 Function<? super T,U> a) {
721 >                return f.applyToEitherAsync(g, a);
722 >            }
723 >        },
724 >
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);
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);
760 >                return f.whenCompleteAsync(a, new ThreadExecutor());
761              }
563        },
564
565 //         REVERSE_DEFAULT_ASYNC {
566 //             public <T,U> CompletableFuture<Void> runAfterBoth
567 //                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
568 //                 return f.runAfterBothAsync(g, a);
569 //             }
570 //             public <T,U> CompletableFuture<Void> thenAcceptBoth
571 //                 (CompletableFuture<T> f,
572 //                  CompletionStage<? extends U> g,
573 //                  BiConsumer<? super T,? super U> a) {
574 //                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
575 //             }
576 //         },
577
578        EXECUTOR {
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 592 | Line 775 | public class CompletableFutureTest exten
775                   BiFunction<? super T,? super U,? extends V> a) {
776                  return f.thenCombineAsync(g, a, new ThreadExecutor());
777              }
595            public <T,U> CompletableFuture<U> applyToEither
596                (CompletableFuture<T> f,
597                 CompletionStage<? extends T> g,
598                 Function<? super T,U> a) {
599                return f.applyToEitherAsync(g, a, new ThreadExecutor());
600            }
601            public <T> CompletableFuture<Void> acceptEither
602                (CompletableFuture<T> f,
603                 CompletionStage<? extends T> g,
604                 Consumer<? super T> a) {
605                return f.acceptEitherAsync(g, a, new ThreadExecutor());
606            }
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,U> CompletableFuture<U> thenCompose
784 >            public <T> CompletableFuture<Void> acceptEither
785                  (CompletableFuture<T> f,
786 <                 Function<? super T,? extends CompletionStage<U>> a) {
787 <                return f.thenComposeAsync(a, new ThreadExecutor());
786 >                 CompletionStage<? extends T> g,
787 >                 Consumer<? super T> a) {
788 >                return f.acceptEitherAsync(g, a, new ThreadExecutor());
789              }
790 <            public <T> CompletableFuture<T> whenComplete
790 >            public <T,U> CompletableFuture<U> applyToEither
791                  (CompletableFuture<T> f,
792 <                 BiConsumer<? super T,? super Throwable> a) {
793 <                return f.whenCompleteAsync(a, new ThreadExecutor());
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
# Line 632 | Line 823 | public class CompletableFutureTest exten
823              (CompletableFuture<T> f,
824               CompletionStage<? extends U> g,
825               BiFunction<? super T,? super U,? extends V> a);
635        public abstract <T,U> CompletableFuture<U> applyToEither
636            (CompletableFuture<T> f,
637             CompletionStage<? extends T> g,
638             Function<? super T,U> a);
639        public abstract <T> CompletableFuture<Void> acceptEither
640            (CompletableFuture<T> f,
641             CompletionStage<? extends T> g,
642             Consumer<? super T> a);
826          public abstract <T> CompletableFuture<Void> runAfterEither
827              (CompletableFuture<T> f,
828               CompletionStage<?> g,
829               java.lang.Runnable a);
830 <        public abstract <T,U> CompletableFuture<U> thenCompose
830 >        public abstract <T> CompletableFuture<Void> acceptEither
831              (CompletableFuture<T> f,
832 <             Function<? super T,? extends CompletionStage<U>> a);
833 <        public abstract <T> CompletableFuture<T> whenComplete
832 >             CompletionStage<? extends T> g,
833 >             Consumer<? super T> a);
834 >        public abstract <T,U> CompletableFuture<U> applyToEither
835              (CompletableFuture<T> f,
836 <             BiConsumer<? super T,? super Throwable> a);
837 <
654 <
655 <    }
656 <
657 <    /**
658 <     * exceptionally action completes with function value on source
659 <     * exception; otherwise with source value
660 <     */
661 <    public void testExceptionally() {
662 <        CompletableFuture<Integer> f = new CompletableFuture<>();
663 <        ExceptionToInteger r = new ExceptionToInteger();
664 <        CompletableFuture<Integer> g = f.exceptionally(r);
665 <        f.completeExceptionally(new CFException());
666 <        checkCompletedNormally(g, three);
667 <
668 <        f = new CompletableFuture<>();
669 <        r = new ExceptionToInteger();
670 <        g = f.exceptionally(r);
671 <        f.complete(one);
672 <        checkCompletedNormally(g, one);
673 <    }
674 <
675 <    /**
676 <     * handle action completes normally with function value on either
677 <     * normal or exceptional completion of source
678 <     */
679 <    public void testHandle() {
680 <        CompletableFuture<Integer> f, g;
681 <        IntegerHandler r;
682 <
683 <        f = new CompletableFuture<>();
684 <        f.completeExceptionally(new CFException());
685 <        g = f.handle(r = new IntegerHandler());
686 <        assertTrue(r.ran);
687 <        checkCompletedNormally(g, three);
688 <
689 <        f = new CompletableFuture<>();
690 <        g = f.handle(r = new IntegerHandler());
691 <        assertFalse(r.ran);
692 <        f.completeExceptionally(new CFException());
693 <        checkCompletedNormally(g, three);
694 <        assertTrue(r.ran);
695 <
696 <        f = new CompletableFuture<>();
697 <        f.complete(one);
698 <        g = f.handle(r = new IntegerHandler());
699 <        assertTrue(r.ran);
700 <        checkCompletedNormally(g, two);
701 <
702 <        f = new CompletableFuture<>();
703 <        g = f.handle(r = new IntegerHandler());
704 <        assertFalse(r.ran);
705 <        f.complete(one);
706 <        assertTrue(r.ran);
707 <        checkCompletedNormally(g, two);
708 <    }
709 <
710 <    /**
711 <     * runAsync completes after running Runnable
712 <     */
713 <    public void testRunAsync() {
714 <        Noop r = new Noop();
715 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
716 <        assertNull(f.join());
717 <        assertTrue(r.ran);
718 <        checkCompletedNormally(f, null);
719 <    }
720 <
721 <    /**
722 <     * runAsync with executor completes after running Runnable
723 <     */
724 <    public void testRunAsync2() {
725 <        Noop r = new Noop();
726 <        ThreadExecutor exec = new ThreadExecutor();
727 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
728 <        assertNull(f.join());
729 <        assertTrue(r.ran);
730 <        checkCompletedNormally(f, null);
731 <        assertEquals(1, exec.count.get());
732 <    }
733 <
734 <    /**
735 <     * failing runAsync completes exceptionally after running Runnable
736 <     */
737 <    public void testRunAsync3() {
738 <        FailingNoop r = new FailingNoop();
739 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
740 <        checkCompletedWithWrappedCFException(f);
741 <        assertTrue(r.ran);
742 <    }
743 <
744 <    /**
745 <     * supplyAsync completes with result of supplier
746 <     */
747 <    public void testSupplyAsync() {
748 <        CompletableFuture<Integer> f;
749 <        f = CompletableFuture.supplyAsync(supplyOne);
750 <        assertEquals(f.join(), one);
751 <        checkCompletedNormally(f, one);
752 <    }
753 <
754 <    /**
755 <     * supplyAsync with executor completes with result of supplier
756 <     */
757 <    public void testSupplyAsync2() {
758 <        CompletableFuture<Integer> f;
759 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
760 <        assertEquals(f.join(), one);
761 <        checkCompletedNormally(f, one);
762 <    }
763 <
764 <    /**
765 <     * Failing supplyAsync completes exceptionally
766 <     */
767 <    public void testSupplyAsync3() {
768 <        FailingSupplier r = new FailingSupplier();
769 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
770 <        checkCompletedWithWrappedCFException(f);
771 <        assertTrue(r.ran);
772 <    }
773 <
774 <    // seq completion methods
775 <
776 <    /**
777 <     * thenRun result completes normally after normal completion of source
778 <     */
779 <    public void testThenRun() {
780 <        CompletableFuture<Integer> f;
781 <        CompletableFuture<Void> g;
782 <        Noop r;
783 <
784 <        f = new CompletableFuture<>();
785 <        g = f.thenRun(r = new Noop());
786 <        f.complete(null);
787 <        checkCompletedNormally(g, null);
788 <        assertTrue(r.ran);
789 <
790 <        f = new CompletableFuture<>();
791 <        f.complete(null);
792 <        g = f.thenRun(r = new Noop());
793 <        checkCompletedNormally(g, null);
794 <        assertTrue(r.ran);
795 <    }
796 <
797 <    /**
798 <     * thenRun result completes exceptionally after exceptional
799 <     * completion of source
800 <     */
801 <    public void testThenRun2() {
802 <        CompletableFuture<Integer> f;
803 <        CompletableFuture<Void> g;
804 <        Noop r;
805 <
806 <        f = new CompletableFuture<>();
807 <        g = f.thenRun(r = new Noop());
808 <        f.completeExceptionally(new CFException());
809 <        checkCompletedWithWrappedCFException(g);
810 <        assertFalse(r.ran);
811 <
812 <        f = new CompletableFuture<>();
813 <        f.completeExceptionally(new CFException());
814 <        g = f.thenRun(r = new Noop());
815 <        checkCompletedWithWrappedCFException(g);
816 <        assertFalse(r.ran);
836 >             CompletionStage<? extends T> g,
837 >             Function<? super T,U> a);
838      }
839  
840      /**
841 <     * thenRun result completes exceptionally if action does
841 >     * exceptionally action is not invoked when source completes
842 >     * normally, and source result is propagated
843       */
844 <    public void testThenRun3() {
845 <        CompletableFuture<Integer> f;
846 <        CompletableFuture<Void> g;
847 <        FailingNoop r;
848 <
849 <        f = new CompletableFuture<>();
850 <        g = f.thenRun(r = new FailingNoop());
851 <        f.complete(null);
852 <        checkCompletedWithWrappedCFException(g);
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 <        f = new CompletableFuture<>();
860 <        f.complete(null);
861 <        g = f.thenRun(r = new FailingNoop());
862 <        checkCompletedWithWrappedCFException(g);
836 <    }
859 >        checkCompletedNormally(g, v1);
860 >        checkCompletedNormally(f, v1);
861 >        assertEquals(0, a.get());
862 >    }}
863  
864      /**
865 <     * thenRun result completes exceptionally if source cancelled
865 >     * exceptionally action completes with function value on source
866 >     * exception
867       */
868 <    public void testThenRun4() {
869 <        CompletableFuture<Integer> f;
870 <        CompletableFuture<Void> g;
871 <        Noop r;
872 <
873 <        f = new CompletableFuture<>();
874 <        g = f.thenRun(r = new Noop());
875 <        assertTrue(f.cancel(true));
876 <        checkCompletedWithWrappedCancellationException(g);
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 <        assertTrue(f.cancel(true));
887 <        g = f.thenRun(r = new Noop());
854 <        checkCompletedWithWrappedCancellationException(g);
855 <    }
885 >        checkCompletedNormally(g, v1);
886 >        assertEquals(1, a.get());
887 >    }}
888  
889 <    /**
890 <     * thenApply result completes normally after normal completion of source
891 <     */
892 <    public void testThenApply() {
893 <        CompletableFuture<Integer> f = new CompletableFuture<>();
894 <        CompletableFuture<Integer> g = f.thenApply(inc);
895 <        f.complete(one);
896 <        checkCompletedNormally(g, two);
897 <    }
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 <    /**
908 <     * thenApply result completes exceptionally after exceptional
909 <     * completion of source
870 <     */
871 <    public void testThenApply2() {
872 <        CompletableFuture<Integer> f = new CompletableFuture<>();
873 <        CompletableFuture<Integer> g = f.thenApply(inc);
874 <        f.completeExceptionally(new CFException());
875 <        checkCompletedWithWrappedCFException(g);
876 <    }
907 >        checkCompletedWithWrappedException(g, ex2);
908 >        assertEquals(1, a.get());
909 >    }}
910  
911      /**
912 <     * thenApply result completes exceptionally if action does
912 >     * whenComplete action executes on normal completion, propagating
913 >     * source result.
914       */
915 <    public void testThenApply3() {
916 <        CompletableFuture<Integer> f = new CompletableFuture<>();
917 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
918 <        f.complete(one);
919 <        checkCompletedWithWrappedCFException(g);
920 <    }
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 <    /**
934 <     * thenApply result completes exceptionally if source cancelled
935 <     */
936 <    public void testThenApply4() {
892 <        CompletableFuture<Integer> f = new CompletableFuture<>();
893 <        CompletableFuture<Integer> g = f.thenApply(inc);
894 <        assertTrue(f.cancel(true));
895 <        checkCompletedWithWrappedCancellationException(g);
896 <    }
933 >        checkCompletedNormally(g, v1);
934 >        checkCompletedNormally(f, v1);
935 >        assertEquals(1, a.get());
936 >    }}
937  
938      /**
939 <     * thenAccept result completes normally after normal completion of source
939 >     * whenComplete action executes on exceptional completion, propagating
940 >     * source result.
941       */
942 <    public void testThenAccept() {
943 <        CompletableFuture<Integer> f = new CompletableFuture<>();
944 <        IncAction r = new IncAction();
945 <        CompletableFuture<Void> g = f.thenAccept(r);
946 <        f.complete(one);
947 <        checkCompletedNormally(g, null);
948 <        assertEquals(r.value, (Integer) 2);
949 <    }
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 <    /**
962 <     * thenAccept result completes exceptionally after exceptional
963 <     * completion of source
964 <     */
914 <    public void testThenAccept2() {
915 <        CompletableFuture<Integer> f = new CompletableFuture<>();
916 <        IncAction r = new IncAction();
917 <        CompletableFuture<Void> g = f.thenAccept(r);
918 <        f.completeExceptionally(new CFException());
919 <        checkCompletedWithWrappedCFException(g);
920 <    }
961 >        checkCompletedWithWrappedException(g, ex);
962 >        checkCompletedExceptionally(f, ex);
963 >        assertEquals(1, a.get());
964 >    }}
965  
966      /**
967 <     * thenAccept result completes exceptionally if action does
967 >     * whenComplete action executes on cancelled source, propagating
968 >     * CancellationException.
969       */
970 <    public void testThenAccept3() {
971 <        CompletableFuture<Integer> f = new CompletableFuture<>();
972 <        FailingConsumer r = new FailingConsumer();
973 <        CompletableFuture<Void> g = f.thenAccept(r);
974 <        f.complete(one);
975 <        checkCompletedWithWrappedCFException(g);
976 <        assertTrue(r.ran);
977 <    }
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  
934    /**
935     * thenAccept result completes exceptionally if source cancelled
936     */
937    public void testThenAccept4() {
938        CompletableFuture<Integer> f = new CompletableFuture<>();
939        IncAction r = new IncAction();
940        CompletableFuture<Void> g = f.thenAccept(r);
941        assertTrue(f.cancel(true));
988          checkCompletedWithWrappedCancellationException(g);
989 <    }
989 >        checkCancelled(f);
990 >        assertEquals(1, a.get());
991 >    }}
992  
993      /**
994 <     * thenCombine result completes normally after normal completion
995 <     * of sources
994 >     * If a whenComplete action throws an exception when triggered by
995 >     * a normal completion, it completes exceptionally
996       */
997 <    public void testThenCombine_normalCompletion1() {
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 <        for (Integer v2 : new Integer[] { 2, null }) {
1002 <
1001 >    {
1002 >        final AtomicInteger a = new AtomicInteger(0);
1003 >        final CFException ex = new CFException();
1004          final CompletableFuture<Integer> f = new CompletableFuture<>();
1005 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1006 <        final SubtractFunction r = new SubtractFunction();
1007 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1008 <
1009 <        f.complete(v1);
1010 <        checkIncomplete(h);
1011 <        assertEquals(r.invocationCount, 0);
1012 <        g.complete(v2);
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 <        checkCompletedNormally(h, subtract(v1, v2));
1017 >        checkCompletedWithWrappedException(g, ex);
1018          checkCompletedNormally(f, v1);
1019 <        checkCompletedNormally(g, v2);
1020 <        assertEquals(r.invocationCount, 1);
968 <        }
969 <    }
1019 >        assertEquals(1, a.get());
1020 >    }}
1021  
1022 <    public void testThenCombine_normalCompletion2() {
1022 >    /**
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 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 <        for (Integer v2 : new Integer[] { 2, null }) {
1032 <
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<>();
977        final CompletableFuture<Integer> g = new CompletableFuture<>();
978        final SubtractFunction r = new SubtractFunction();
979        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1036  
1037 <        g.complete(v2);
1038 <        checkIncomplete(h);
1039 <        assertEquals(r.invocationCount, 0);
1040 <        f.complete(v1);
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 <        checkCompletedNormally(h, subtract(v1, v2));
1050 <        checkCompletedNormally(f, v1);
1051 <        checkCompletedNormally(g, v2);
1052 <        assertEquals(r.invocationCount, 1);
990 <        }
991 <    }
1049 >        checkCompletedWithWrappedException(g, ex1);
1050 >        checkCompletedExceptionally(f, ex1);
1051 >        assertEquals(1, a.get());
1052 >    }}
1053  
1054 <    public void testThenCombine_normalCompletion3() {
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 <        for (Integer v2 : new Integer[] { 2, null }) {
997 <
1062 >    {
1063          final CompletableFuture<Integer> f = new CompletableFuture<>();
1064 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1065 <        final SubtractFunction r = new SubtractFunction();
1066 <
1067 <        g.complete(v2);
1068 <        f.complete(v1);
1069 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
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(h, subtract(v1, v2));
1077 >        checkCompletedNormally(g, inc(v1));
1078          checkCompletedNormally(f, v1);
1079 <        checkCompletedNormally(g, v2);
1080 <        assertEquals(r.invocationCount, 1);
1010 <        }
1011 <    }
1079 >        assertEquals(1, a.get());
1080 >    }}
1081  
1082 <    public void testThenCombine_normalCompletion4() {
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 <        for (Integer v2 : new Integer[] { 2, null }) {
1017 <
1090 >    {
1091          final CompletableFuture<Integer> f = new CompletableFuture<>();
1092 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1093 <        final SubtractFunction r = new SubtractFunction();
1094 <
1095 <        f.complete(v1);
1096 <        g.complete(v2);
1097 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
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(h, subtract(v1, v2));
1107 <        checkCompletedNormally(f, v1);
1108 <        checkCompletedNormally(g, v2);
1109 <        assertEquals(r.invocationCount, 1);
1030 <        }
1031 <    }
1106 >        checkCompletedNormally(g, v1);
1107 >        checkCompletedExceptionally(f, ex);
1108 >        assertEquals(1, a.get());
1109 >    }}
1110  
1111      /**
1112 <     * thenCombine result completes exceptionally after exceptional
1113 <     * completion of either source
1112 >     * handle action completes normally with function value on
1113 >     * cancelled source
1114       */
1115 <    public void testThenCombine_exceptionalCompletion1() {
1115 >    public void testHandle_sourceCancelled() {
1116          for (ExecutionMode m : ExecutionMode.values())
1117 <        for (Integer v1 : new Integer[] { 1, null }) {
1118 <
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 CompletableFuture<Integer> g = new CompletableFuture<>();
1123 <        final SubtractFunction r = new SubtractFunction();
1124 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1125 <        final CFException ex = new CFException();
1126 <
1127 <        f.completeExceptionally(ex);
1128 <        checkIncomplete(h);
1129 <        g.complete(v1);
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  
1051        checkCompletedWithWrappedCFException(h, ex);
1052        checkCompletedWithWrappedCFException(f, ex);
1053        assertEquals(r.invocationCount, 0);
1135          checkCompletedNormally(g, v1);
1136 <        }
1137 <    }
1136 >        checkCancelled(f);
1137 >        assertEquals(1, a.get());
1138 >    }}
1139  
1140 <    public void testThenCombine_exceptionalCompletion2() {
1140 >    /**
1141 >     * handle result completes exceptionally if action does
1142 >     */
1143 >    public void testHandle_sourceFailedActionFailed() {
1144          for (ExecutionMode m : ExecutionMode.values())
1145 <        for (Integer v1 : new Integer[] { 1, null }) {
1146 <
1145 >        for (boolean createIncomplete : new boolean[] { true, false })
1146 >    {
1147          final CompletableFuture<Integer> f = new CompletableFuture<>();
1148 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1149 <        final SubtractFunction r = new SubtractFunction();
1150 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1151 <        final CFException ex = new CFException();
1152 <
1153 <        g.completeExceptionally(ex);
1154 <        checkIncomplete(h);
1155 <        f.complete(v1);
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 <        checkCompletedWithWrappedCFException(h, ex);
1164 <        checkCompletedWithWrappedCFException(g, ex);
1165 <        assertEquals(r.invocationCount, 0);
1166 <        checkCompletedNormally(f, v1);
1076 <        }
1077 <    }
1163 >        checkCompletedWithWrappedException(g, ex2);
1164 >        checkCompletedExceptionally(f, ex1);
1165 >        assertEquals(1, a.get());
1166 >    }}
1167  
1168 <    public void testThenCombine_exceptionalCompletion3() {
1168 >    public void testHandle_sourceCompletedNormallyActionFailed() {
1169          for (ExecutionMode m : ExecutionMode.values())
1170 <        for (Integer v1 : new Integer[] { 1, null }) {
1171 <
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 CompletableFuture<Integer> g = new CompletableFuture<>();
1085 <        final SubtractFunction r = new SubtractFunction();
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 <        g.completeExceptionally(ex);
1089 <        f.complete(v1);
1090 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1091 <
1092 <        checkCompletedWithWrappedCFException(h, ex);
1093 <        checkCompletedWithWrappedCFException(g, ex);
1094 <        assertEquals(r.invocationCount, 0);
1188 >        checkCompletedWithWrappedException(g, ex);
1189          checkCompletedNormally(f, v1);
1190 <        }
1191 <    }
1098 <
1099 <    public void testThenCombine_exceptionalCompletion4() {
1100 <        for (ExecutionMode m : ExecutionMode.values())
1101 <        for (Integer v1 : new Integer[] { 1, null }) {
1102 <
1103 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1104 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1105 <        final SubtractFunction r = new SubtractFunction();
1106 <        final CFException ex = new CFException();
1107 <
1108 <        f.completeExceptionally(ex);
1109 <        g.complete(v1);
1110 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1111 <
1112 <        checkCompletedWithWrappedCFException(h, ex);
1113 <        checkCompletedWithWrappedCFException(f, ex);
1114 <        assertEquals(r.invocationCount, 0);
1115 <        checkCompletedNormally(g, v1);
1116 <        }
1117 <    }
1190 >        assertEquals(1, a.get());
1191 >    }}
1192  
1193      /**
1194 <     * thenCombine result completes exceptionally if action does
1194 >     * runAsync completes after running Runnable
1195       */
1196 <    public void testThenCombine_actionFailed1() {
1197 <        for (ExecutionMode m : ExecutionMode.values())
1198 <        for (Integer v1 : new Integer[] { 1, null })
1199 <        for (Integer v2 : new Integer[] { 2, null }) {
1200 <
1201 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1202 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1203 <        final FailingBiFunction r = new FailingBiFunction();
1204 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1205 <
1206 <        f.complete(v1);
1207 <        checkIncomplete(h);
1208 <        g.complete(v2);
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());
1206 >        checkCompletedNormally(f, null);
1207 >        r.assertInvoked();
1208 >    }}
1209  
1210 <        checkCompletedWithWrappedCFException(h);
1211 <        checkCompletedNormally(f, v1);
1212 <        checkCompletedNormally(g, v2);
1213 <        }
1214 <    }
1210 >    /**
1211 >     * failing runAsync completes exceptionally after running Runnable
1212 >     */
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 >        r.assertInvoked();
1224 >    }}
1225  
1226 <    public void testThenCombine_actionFailed2() {
1227 <        for (ExecutionMode m : ExecutionMode.values())
1226 >    /**
1227 >     * supplyAsync completes with result of supplier
1228 >     */
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 <        for (Integer v2 : new Integer[] { 2, null }) {
1237 <
1238 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1239 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1149 <        final FailingBiFunction r = new FailingBiFunction();
1150 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1151 <
1152 <        g.complete(v2);
1153 <        checkIncomplete(h);
1154 <        f.complete(v1);
1155 <
1156 <        checkCompletedWithWrappedCFException(h);
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 <        checkCompletedNormally(g, v2);
1242 <        }
1160 <    }
1241 >        r.assertInvoked();
1242 >    }}
1243  
1244      /**
1245 <     * thenCombine result completes exceptionally if either source cancelled
1245 >     * Failing supplyAsync completes exceptionally
1246       */
1247 <    public void testThenCombine_sourceCancelled1() {
1248 <        for (ExecutionMode m : ExecutionMode.values())
1249 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1250 <        for (Integer v1 : new Integer[] { 1, null }) {
1251 <
1252 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1253 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1254 <        final SubtractFunction r = new SubtractFunction();
1255 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1256 <
1257 <        assertTrue(f.cancel(mayInterruptIfRunning));
1258 <        checkIncomplete(h);
1177 <        g.complete(v1);
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 >        r.assertInvoked();
1258 >    }}
1259  
1260 <        checkCompletedWithWrappedCancellationException(h);
1180 <        checkCancelled(f);
1181 <        assertEquals(r.invocationCount, 0);
1182 <        checkCompletedNormally(g, v1);
1183 <        }
1184 <    }
1260 >    // seq completion methods
1261  
1262 <    public void testThenCombine_sourceCancelled2() {
1262 >    /**
1263 >     * thenRun result completes normally after normal completion of source
1264 >     */
1265 >    public void testThenRun_normalCompletion() {
1266          for (ExecutionMode m : ExecutionMode.values())
1267 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1268 <        for (Integer v1 : new Integer[] { 1, null }) {
1190 <
1267 >        for (Integer v1 : new Integer[] { 1, null })
1268 >    {
1269          final CompletableFuture<Integer> f = new CompletableFuture<>();
1270 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1271 <        final SubtractFunction r = new SubtractFunction();
1194 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1195 <
1196 <        assertTrue(g.cancel(mayInterruptIfRunning));
1197 <        checkIncomplete(h);
1198 <        f.complete(v1);
1270 >        final Noop[] rs = new Noop[6];
1271 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1272  
1273 <        checkCompletedWithWrappedCancellationException(h);
1274 <        checkCancelled(g);
1275 <        assertEquals(r.invocationCount, 0);
1273 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1274 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1275 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1276 >        checkIncomplete(h0);
1277 >        checkIncomplete(h1);
1278 >        checkIncomplete(h2);
1279 >        assertTrue(f.complete(v1));
1280 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1281 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1282 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1283 >
1284 >        checkCompletedNormally(h0, null);
1285 >        checkCompletedNormally(h1, null);
1286 >        checkCompletedNormally(h2, null);
1287 >        checkCompletedNormally(h3, null);
1288 >        checkCompletedNormally(h4, null);
1289 >        checkCompletedNormally(h5, null);
1290          checkCompletedNormally(f, v1);
1291 <        }
1292 <    }
1291 >        for (Noop r : rs) r.assertInvoked();
1292 >    }}
1293  
1294 <    public void testThenCombine_sourceCancelled3() {
1294 >    /**
1295 >     * thenRun result completes exceptionally after exceptional
1296 >     * completion of source
1297 >     */
1298 >    public void testThenRun_exceptionalCompletion() {
1299          for (ExecutionMode m : ExecutionMode.values())
1300 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1301 <        for (Integer v1 : new Integer[] { 1, null }) {
1211 <
1300 >    {
1301 >        final CFException ex = new CFException();
1302          final CompletableFuture<Integer> f = new CompletableFuture<>();
1303 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1304 <        final SubtractFunction r = new SubtractFunction();
1303 >        final Noop[] rs = new Noop[6];
1304 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1305  
1306 <        assertTrue(g.cancel(mayInterruptIfRunning));
1307 <        f.complete(v1);
1308 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1309 <
1310 <        checkCompletedWithWrappedCancellationException(h);
1311 <        checkCancelled(g);
1312 <        assertEquals(r.invocationCount, 0);
1313 <        checkCompletedNormally(f, v1);
1314 <        }
1315 <    }
1306 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1307 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1308 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1309 >        checkIncomplete(h0);
1310 >        checkIncomplete(h1);
1311 >        checkIncomplete(h2);
1312 >        assertTrue(f.completeExceptionally(ex));
1313 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1314 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1315 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1316 >
1317 >        checkCompletedWithWrappedException(h0, ex);
1318 >        checkCompletedWithWrappedException(h1, ex);
1319 >        checkCompletedWithWrappedException(h2, ex);
1320 >        checkCompletedWithWrappedException(h3, ex);
1321 >        checkCompletedWithWrappedException(h4, ex);
1322 >        checkCompletedWithWrappedException(h5, ex);
1323 >        checkCompletedExceptionally(f, ex);
1324 >        for (Noop r : rs) r.assertNotInvoked();
1325 >    }}
1326  
1327 <    public void testThenCombine_sourceCancelled4() {
1327 >    /**
1328 >     * thenRun result completes exceptionally if source cancelled
1329 >     */
1330 >    public void testThenRun_sourceCancelled() {
1331          for (ExecutionMode m : ExecutionMode.values())
1332          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1333 <        for (Integer v1 : new Integer[] { 1, null }) {
1231 <
1333 >    {
1334          final CompletableFuture<Integer> f = new CompletableFuture<>();
1335 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1336 <        final SubtractFunction r = new SubtractFunction();
1335 >        final Noop[] rs = new Noop[6];
1336 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1337  
1338 +        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1339 +        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1340 +        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1341 +        checkIncomplete(h0);
1342 +        checkIncomplete(h1);
1343 +        checkIncomplete(h2);
1344          assertTrue(f.cancel(mayInterruptIfRunning));
1345 <        g.complete(v1);
1346 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1347 <
1348 <        checkCompletedWithWrappedCancellationException(h);
1345 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1346 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1347 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1348 >
1349 >        checkCompletedWithWrappedCancellationException(h0);
1350 >        checkCompletedWithWrappedCancellationException(h1);
1351 >        checkCompletedWithWrappedCancellationException(h2);
1352 >        checkCompletedWithWrappedCancellationException(h3);
1353 >        checkCompletedWithWrappedCancellationException(h4);
1354 >        checkCompletedWithWrappedCancellationException(h5);
1355          checkCancelled(f);
1356 <        assertEquals(r.invocationCount, 0);
1357 <        checkCompletedNormally(g, v1);
1244 <        }
1245 <    }
1356 >        for (Noop r : rs) r.assertNotInvoked();
1357 >    }}
1358  
1359      /**
1360 <     * thenAcceptBoth result completes normally after normal
1249 <     * completion of sources
1360 >     * thenRun result completes exceptionally if action does
1361       */
1362 <    public void testThenAcceptBoth_normalCompletion1() {
1252 <        for (ExecutionMode m : ExecutionMode.values())
1253 <        for (Integer v1 : new Integer[] { 1, null })
1254 <        for (Integer v2 : new Integer[] { 2, null }) {
1255 <
1256 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1257 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1258 <        final SubtractAction r = new SubtractAction();
1259 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1260 <
1261 <        f.complete(v1);
1262 <        checkIncomplete(h);
1263 <        assertFalse(r.ran());
1264 <        g.complete(v2);
1265 <
1266 <        checkCompletedNormally(h, null);
1267 <        assertEquals(r.value, subtract(v1, v2));
1268 <        checkCompletedNormally(f, v1);
1269 <        checkCompletedNormally(g, v2);
1270 <        }
1271 <    }
1272 <
1273 <    public void testThenAcceptBoth_normalCompletion2() {
1274 <        for (ExecutionMode m : ExecutionMode.values())
1275 <        for (Integer v1 : new Integer[] { 1, null })
1276 <        for (Integer v2 : new Integer[] { 2, null }) {
1277 <
1278 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1279 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1280 <        final SubtractAction r = new SubtractAction();
1281 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1282 <
1283 <        g.complete(v2);
1284 <        checkIncomplete(h);
1285 <        assertFalse(r.ran());
1286 <        f.complete(v1);
1287 <
1288 <        checkCompletedNormally(h, null);
1289 <        assertEquals(r.value, subtract(v1, v2));
1290 <        checkCompletedNormally(f, v1);
1291 <        checkCompletedNormally(g, v2);
1292 <        }
1293 <    }
1294 <
1295 <    public void testThenAcceptBoth_normalCompletion3() {
1362 >    public void testThenRun_actionFailed() {
1363          for (ExecutionMode m : ExecutionMode.values())
1364          for (Integer v1 : new Integer[] { 1, null })
1365 <        for (Integer v2 : new Integer[] { 2, null }) {
1299 <
1365 >    {
1366          final CompletableFuture<Integer> f = new CompletableFuture<>();
1367 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1368 <        final SubtractAction r = new SubtractAction();
1367 >        final FailingRunnable[] rs = new FailingRunnable[6];
1368 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
1369  
1370 <        g.complete(v2);
1371 <        f.complete(v1);
1372 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1373 <
1374 <        checkCompletedNormally(h, null);
1375 <        assertEquals(r.value, subtract(v1, v2));
1370 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1371 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1372 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1373 >        assertTrue(f.complete(v1));
1374 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1375 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1376 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1377 >
1378 >        checkCompletedWithWrappedCFException(h0);
1379 >        checkCompletedWithWrappedCFException(h1);
1380 >        checkCompletedWithWrappedCFException(h2);
1381 >        checkCompletedWithWrappedCFException(h3);
1382 >        checkCompletedWithWrappedCFException(h4);
1383 >        checkCompletedWithWrappedCFException(h5);
1384          checkCompletedNormally(f, v1);
1385 <        checkCompletedNormally(g, v2);
1312 <        }
1313 <    }
1385 >    }}
1386  
1387 <    public void testThenAcceptBoth_normalCompletion4() {
1387 >    /**
1388 >     * thenApply result completes normally after normal completion of source
1389 >     */
1390 >    public void testThenApply_normalCompletion() {
1391          for (ExecutionMode m : ExecutionMode.values())
1392          for (Integer v1 : new Integer[] { 1, null })
1393 <        for (Integer v2 : new Integer[] { 2, null }) {
1319 <
1393 >    {
1394          final CompletableFuture<Integer> f = new CompletableFuture<>();
1395 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1396 <        final SubtractAction r = new SubtractAction();
1395 >        final IncFunction[] rs = new IncFunction[4];
1396 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1397  
1398 <        f.complete(v1);
1399 <        g.complete(v2);
1400 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1398 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1399 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1400 >        checkIncomplete(h0);
1401 >        checkIncomplete(h1);
1402 >        assertTrue(f.complete(v1));
1403 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1404 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1405  
1406 <        checkCompletedNormally(h, null);
1407 <        assertEquals(r.value, subtract(v1, v2));
1406 >        checkCompletedNormally(h0, inc(v1));
1407 >        checkCompletedNormally(h1, inc(v1));
1408 >        checkCompletedNormally(h2, inc(v1));
1409 >        checkCompletedNormally(h3, inc(v1));
1410          checkCompletedNormally(f, v1);
1411 <        checkCompletedNormally(g, v2);
1412 <        }
1333 <    }
1411 >        for (IncFunction r : rs) r.assertValue(inc(v1));
1412 >    }}
1413  
1414      /**
1415 <     * thenAcceptBoth result completes exceptionally after exceptional
1416 <     * completion of either source
1415 >     * thenApply result completes exceptionally after exceptional
1416 >     * completion of source
1417       */
1418 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1418 >    public void testThenApply_exceptionalCompletion() {
1419          for (ExecutionMode m : ExecutionMode.values())
1420 <        for (Integer v1 : new Integer[] { 1, null }) {
1342 <
1343 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1344 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1345 <        final SubtractAction r = new SubtractAction();
1346 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1420 >    {
1421          final CFException ex = new CFException();
1348
1349        f.completeExceptionally(ex);
1350        checkIncomplete(h);
1351        g.complete(v1);
1352
1353        checkCompletedWithWrappedCFException(h, ex);
1354        checkCompletedWithWrappedCFException(f, ex);
1355        assertEquals(r.invocationCount, 0);
1356        checkCompletedNormally(g, v1);
1357        }
1358    }
1359
1360    public void testThenAcceptBoth_exceptionalCompletion2() {
1361        for (ExecutionMode m : ExecutionMode.values())
1362        for (Integer v1 : new Integer[] { 1, null }) {
1363
1422          final CompletableFuture<Integer> f = new CompletableFuture<>();
1423 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1424 <        final SubtractAction r = new SubtractAction();
1367 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1368 <        final CFException ex = new CFException();
1423 >        final IncFunction[] rs = new IncFunction[4];
1424 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1425  
1426 <        g.completeExceptionally(ex);
1427 <        checkIncomplete(h);
1428 <        f.complete(v1);
1426 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1427 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1428 >        assertTrue(f.completeExceptionally(ex));
1429 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1430 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1431 >
1432 >        checkCompletedWithWrappedException(h0, ex);
1433 >        checkCompletedWithWrappedException(h1, ex);
1434 >        checkCompletedWithWrappedException(h2, ex);
1435 >        checkCompletedWithWrappedException(h3, ex);
1436 >        checkCompletedExceptionally(f, ex);
1437 >        for (IncFunction r : rs) r.assertNotInvoked();
1438 >    }}
1439  
1440 <        checkCompletedWithWrappedCFException(h, ex);
1441 <        checkCompletedWithWrappedCFException(g, ex);
1442 <        assertEquals(r.invocationCount, 0);
1443 <        checkCompletedNormally(f, v1);
1378 <        }
1379 <    }
1380 <
1381 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1440 >    /**
1441 >     * thenApply result completes exceptionally if source cancelled
1442 >     */
1443 >    public void testThenApply_sourceCancelled() {
1444          for (ExecutionMode m : ExecutionMode.values())
1445 <        for (Integer v1 : new Integer[] { 1, null }) {
1446 <
1445 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1446 >    {
1447          final CompletableFuture<Integer> f = new CompletableFuture<>();
1448 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1449 <        final SubtractAction r = new SubtractAction();
1388 <        final CFException ex = new CFException();
1448 >        final IncFunction[] rs = new IncFunction[4];
1449 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1450  
1451 <        g.completeExceptionally(ex);
1452 <        f.complete(v1);
1453 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1451 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1452 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1453 >        assertTrue(f.cancel(mayInterruptIfRunning));
1454 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1455 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1456  
1457 <        checkCompletedWithWrappedCFException(h, ex);
1458 <        checkCompletedWithWrappedCFException(g, ex);
1459 <        assertEquals(r.invocationCount, 0);
1460 <        checkCompletedNormally(f, v1);
1461 <        }
1462 <    }
1457 >        checkCompletedWithWrappedCancellationException(h0);
1458 >        checkCompletedWithWrappedCancellationException(h1);
1459 >        checkCompletedWithWrappedCancellationException(h2);
1460 >        checkCompletedWithWrappedCancellationException(h3);
1461 >        checkCancelled(f);
1462 >        for (IncFunction r : rs) r.assertNotInvoked();
1463 >    }}
1464  
1465 <    public void testThenAcceptBoth_exceptionalCompletion4() {
1465 >    /**
1466 >     * thenApply result completes exceptionally if action does
1467 >     */
1468 >    public void testThenApply_actionFailed() {
1469          for (ExecutionMode m : ExecutionMode.values())
1470 <        for (Integer v1 : new Integer[] { 1, null }) {
1471 <
1470 >        for (Integer v1 : new Integer[] { 1, null })
1471 >    {
1472          final CompletableFuture<Integer> f = new CompletableFuture<>();
1473 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1474 <        final SubtractAction r = new SubtractAction();
1408 <        final CFException ex = new CFException();
1473 >        final FailingFunction[] rs = new FailingFunction[4];
1474 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1475  
1476 <        f.completeExceptionally(ex);
1477 <        g.complete(v1);
1478 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1476 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1477 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1478 >        assertTrue(f.complete(v1));
1479 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1480 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1481  
1482 <        checkCompletedWithWrappedCFException(h, ex);
1483 <        checkCompletedWithWrappedCFException(f, ex);
1484 <        assertFalse(r.ran());
1485 <        checkCompletedNormally(g, v1);
1486 <        }
1487 <    }
1482 >        checkCompletedWithWrappedCFException(h0);
1483 >        checkCompletedWithWrappedCFException(h1);
1484 >        checkCompletedWithWrappedCFException(h2);
1485 >        checkCompletedWithWrappedCFException(h3);
1486 >        checkCompletedNormally(f, v1);
1487 >    }}
1488  
1489      /**
1490 <     * thenAcceptBoth result completes exceptionally if action does
1490 >     * thenAccept result completes normally after normal completion of source
1491       */
1492 <    public void testThenAcceptBoth_actionFailed1() {
1492 >    public void testThenAccept_normalCompletion() {
1493          for (ExecutionMode m : ExecutionMode.values())
1494          for (Integer v1 : new Integer[] { 1, null })
1495 <        for (Integer v2 : new Integer[] { 2, null }) {
1428 <
1495 >    {
1496          final CompletableFuture<Integer> f = new CompletableFuture<>();
1497 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1498 <        final FailingBiConsumer r = new FailingBiConsumer();
1432 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1497 >        final NoopConsumer[] rs = new NoopConsumer[4];
1498 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1499  
1500 <        f.complete(v1);
1501 <        checkIncomplete(h);
1502 <        g.complete(v2);
1500 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1501 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1502 >        checkIncomplete(h0);
1503 >        checkIncomplete(h1);
1504 >        assertTrue(f.complete(v1));
1505 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1506 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1507  
1508 <        checkCompletedWithWrappedCFException(h);
1508 >        checkCompletedNormally(h0, null);
1509 >        checkCompletedNormally(h1, null);
1510 >        checkCompletedNormally(h2, null);
1511 >        checkCompletedNormally(h3, null);
1512          checkCompletedNormally(f, v1);
1513 <        checkCompletedNormally(g, v2);
1514 <        }
1442 <    }
1513 >        for (NoopConsumer r : rs) r.assertValue(v1);
1514 >    }}
1515  
1516 <    public void testThenAcceptBoth_actionFailed2() {
1516 >    /**
1517 >     * thenAccept result completes exceptionally after exceptional
1518 >     * completion of source
1519 >     */
1520 >    public void testThenAccept_exceptionalCompletion() {
1521          for (ExecutionMode m : ExecutionMode.values())
1522 <        for (Integer v1 : new Integer[] { 1, null })
1523 <        for (Integer v2 : new Integer[] { 2, null }) {
1448 <
1522 >    {
1523 >        final CFException ex = new CFException();
1524          final CompletableFuture<Integer> f = new CompletableFuture<>();
1525 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1526 <        final FailingBiConsumer r = new FailingBiConsumer();
1452 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1525 >        final NoopConsumer[] rs = new NoopConsumer[4];
1526 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1527  
1528 <        g.complete(v2);
1529 <        checkIncomplete(h);
1530 <        f.complete(v1);
1531 <
1532 <        checkCompletedWithWrappedCFException(h);
1533 <        checkCompletedNormally(f, v1);
1534 <        checkCompletedNormally(g, v2);
1535 <        }
1536 <    }
1528 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1529 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1530 >        assertTrue(f.completeExceptionally(ex));
1531 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1532 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1533 >
1534 >        checkCompletedWithWrappedException(h0, ex);
1535 >        checkCompletedWithWrappedException(h1, ex);
1536 >        checkCompletedWithWrappedException(h2, ex);
1537 >        checkCompletedWithWrappedException(h3, ex);
1538 >        checkCompletedExceptionally(f, ex);
1539 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1540 >    }}
1541  
1542      /**
1543 <     * thenAcceptBoth result completes exceptionally if either source cancelled
1543 >     * thenAccept result completes exceptionally if source cancelled
1544       */
1545 <    public void testThenAcceptBoth_sourceCancelled1() {
1545 >    public void testThenAccept_sourceCancelled() {
1546          for (ExecutionMode m : ExecutionMode.values())
1547          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1548 <        for (Integer v1 : new Integer[] { 1, null }) {
1471 <
1548 >    {
1549          final CompletableFuture<Integer> f = new CompletableFuture<>();
1550 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1551 <        final SubtractAction r = new SubtractAction();
1475 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1550 >        final NoopConsumer[] rs = new NoopConsumer[4];
1551 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1552  
1553 +        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1554 +        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1555          assertTrue(f.cancel(mayInterruptIfRunning));
1556 <        checkIncomplete(h);
1557 <        g.complete(v1);
1556 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1557 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1558  
1559 <        checkCompletedWithWrappedCancellationException(h);
1559 >        checkCompletedWithWrappedCancellationException(h0);
1560 >        checkCompletedWithWrappedCancellationException(h1);
1561 >        checkCompletedWithWrappedCancellationException(h2);
1562 >        checkCompletedWithWrappedCancellationException(h3);
1563          checkCancelled(f);
1564 <        assertEquals(r.invocationCount, 0);
1565 <        checkCompletedNormally(g, v1);
1485 <        }
1486 <    }
1564 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1565 >    }}
1566  
1567 <    public void testThenAcceptBoth_sourceCancelled2() {
1567 >    /**
1568 >     * thenAccept result completes exceptionally if action does
1569 >     */
1570 >    public void testThenAccept_actionFailed() {
1571          for (ExecutionMode m : ExecutionMode.values())
1572 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1573 <        for (Integer v1 : new Integer[] { 1, null }) {
1492 <
1572 >        for (Integer v1 : new Integer[] { 1, null })
1573 >    {
1574          final CompletableFuture<Integer> f = new CompletableFuture<>();
1575 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1576 <        final SubtractAction r = new SubtractAction();
1496 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1575 >        final FailingConsumer[] rs = new FailingConsumer[4];
1576 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
1577  
1578 <        assertTrue(g.cancel(mayInterruptIfRunning));
1579 <        checkIncomplete(h);
1580 <        f.complete(v1);
1578 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1579 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1580 >        assertTrue(f.complete(v1));
1581 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1582 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1583  
1584 <        checkCompletedWithWrappedCancellationException(h);
1585 <        checkCancelled(g);
1586 <        assertEquals(r.invocationCount, 0);
1584 >        checkCompletedWithWrappedCFException(h0);
1585 >        checkCompletedWithWrappedCFException(h1);
1586 >        checkCompletedWithWrappedCFException(h2);
1587 >        checkCompletedWithWrappedCFException(h3);
1588          checkCompletedNormally(f, v1);
1589 <        }
1507 <    }
1589 >    }}
1590  
1591 <    public void testThenAcceptBoth_sourceCancelled3() {
1591 >    /**
1592 >     * thenCombine result completes normally after normal completion
1593 >     * of sources
1594 >     */
1595 >    public void testThenCombine_normalCompletion() {
1596          for (ExecutionMode m : ExecutionMode.values())
1597 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1598 <        for (Integer v1 : new Integer[] { 1, null }) {
1599 <
1597 >        for (boolean fFirst : new boolean[] { true, false })
1598 >        for (Integer v1 : new Integer[] { 1, null })
1599 >        for (Integer v2 : new Integer[] { 2, null })
1600 >    {
1601          final CompletableFuture<Integer> f = new CompletableFuture<>();
1602          final CompletableFuture<Integer> g = new CompletableFuture<>();
1603 <        final SubtractAction r = new SubtractAction();
1604 <
1605 <        assertTrue(g.cancel(mayInterruptIfRunning));
1606 <        f.complete(v1);
1607 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1603 >        final SubtractFunction[] rs = new SubtractFunction[6];
1604 >        for (int i = 0; i < rs.length; i++) rs[i] = new SubtractFunction(m);
1605 >
1606 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1607 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1608 >        final Integer w1 =  fFirst ? v1 : v2;
1609 >        final Integer w2 = !fFirst ? v1 : v2;
1610 >
1611 >        final CompletableFuture<Integer> h0 = m.thenCombine(f, g, rs[0]);
1612 >        final CompletableFuture<Integer> h1 = m.thenCombine(fst, fst, rs[1]);
1613 >        assertTrue(fst.complete(w1));
1614 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, rs[2]);
1615 >        final CompletableFuture<Integer> h3 = m.thenCombine(fst, fst, rs[3]);
1616 >        checkIncomplete(h0); rs[0].assertNotInvoked();
1617 >        checkIncomplete(h2); rs[2].assertNotInvoked();
1618 >        checkCompletedNormally(h1, subtract(w1, w1));
1619 >        checkCompletedNormally(h3, subtract(w1, w1));
1620 >        rs[1].assertValue(subtract(w1, w1));
1621 >        rs[3].assertValue(subtract(w1, w1));
1622 >        assertTrue(snd.complete(w2));
1623 >        final CompletableFuture<Integer> h4 = m.thenCombine(f, g, rs[4]);
1624 >
1625 >        checkCompletedNormally(h0, subtract(v1, v2));
1626 >        checkCompletedNormally(h2, subtract(v1, v2));
1627 >        checkCompletedNormally(h4, subtract(v1, v2));
1628 >        rs[0].assertValue(subtract(v1, v2));
1629 >        rs[2].assertValue(subtract(v1, v2));
1630 >        rs[4].assertValue(subtract(v1, v2));
1631  
1522        checkCompletedWithWrappedCancellationException(h);
1523        checkCancelled(g);
1524        assertEquals(r.invocationCount, 0);
1632          checkCompletedNormally(f, v1);
1633 <        }
1634 <    }
1528 <
1529 <    public void testThenAcceptBoth_sourceCancelled4() {
1530 <        for (ExecutionMode m : ExecutionMode.values())
1531 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1532 <        for (Integer v1 : new Integer[] { 1, null }) {
1533 <
1534 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1535 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1536 <        final SubtractAction r = new SubtractAction();
1537 <
1538 <        assertTrue(f.cancel(mayInterruptIfRunning));
1539 <        g.complete(v1);
1540 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1541 <
1542 <        checkCompletedWithWrappedCancellationException(h);
1543 <        checkCancelled(f);
1544 <        assertEquals(r.invocationCount, 0);
1545 <        checkCompletedNormally(g, v1);
1546 <        }
1547 <    }
1633 >        checkCompletedNormally(g, v2);
1634 >    }}
1635  
1636      /**
1637 <     * runAfterBoth result completes normally after normal
1638 <     * completion of sources
1637 >     * thenCombine result completes exceptionally after exceptional
1638 >     * completion of either source
1639       */
1640 <    public void testRunAfterBoth_normalCompletion1() {
1640 >    public void testThenCombine_exceptionalCompletion() throws Throwable {
1641          for (ExecutionMode m : ExecutionMode.values())
1642 +        for (boolean fFirst : new boolean[] { true, false })
1643 +        for (boolean failFirst : new boolean[] { true, false })
1644          for (Integer v1 : new Integer[] { 1, null })
1645 <        for (Integer v2 : new Integer[] { 2, null }) {
1557 <
1645 >    {
1646          final CompletableFuture<Integer> f = new CompletableFuture<>();
1647          final CompletableFuture<Integer> g = new CompletableFuture<>();
1648 <        final Noop r = new Noop();
1649 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1650 <
1651 <        f.complete(v1);
1652 <        checkIncomplete(h);
1653 <        assertFalse(r.ran);
1654 <        g.complete(v2);
1655 <
1656 <        checkCompletedNormally(h, null);
1657 <        assertEquals(r.invocationCount, 1);
1658 <        checkCompletedNormally(f, v1);
1659 <        checkCompletedNormally(g, v2);
1660 <        }
1661 <    }
1648 >        final CFException ex = new CFException();
1649 >        final SubtractFunction r1 = new SubtractFunction(m);
1650 >        final SubtractFunction r2 = new SubtractFunction(m);
1651 >        final SubtractFunction r3 = new SubtractFunction(m);
1652 >
1653 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1654 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1655 >        final Callable<Boolean> complete1 = failFirst ?
1656 >            () -> fst.completeExceptionally(ex) :
1657 >            () -> fst.complete(v1);
1658 >        final Callable<Boolean> complete2 = failFirst ?
1659 >            () -> snd.complete(v1) :
1660 >            () -> snd.completeExceptionally(ex);
1661 >
1662 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1663 >        assertTrue(complete1.call());
1664 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1665 >        checkIncomplete(h1);
1666 >        checkIncomplete(h2);
1667 >        assertTrue(complete2.call());
1668 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1669 >
1670 >        checkCompletedWithWrappedException(h1, ex);
1671 >        checkCompletedWithWrappedException(h2, ex);
1672 >        checkCompletedWithWrappedException(h3, ex);
1673 >        r1.assertNotInvoked();
1674 >        r2.assertNotInvoked();
1675 >        r3.assertNotInvoked();
1676 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1677 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1678 >    }}
1679  
1680 <    public void testRunAfterBoth_normalCompletion2() {
1680 >    /**
1681 >     * thenCombine result completes exceptionally if either source cancelled
1682 >     */
1683 >    public void testThenCombine_sourceCancelled() throws Throwable {
1684          for (ExecutionMode m : ExecutionMode.values())
1685 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1686 +        for (boolean fFirst : new boolean[] { true, false })
1687 +        for (boolean failFirst : new boolean[] { true, false })
1688          for (Integer v1 : new Integer[] { 1, null })
1689 <        for (Integer v2 : new Integer[] { 2, null }) {
1579 <
1689 >    {
1690          final CompletableFuture<Integer> f = new CompletableFuture<>();
1691          final CompletableFuture<Integer> g = new CompletableFuture<>();
1692 <        final Noop r = new Noop();
1693 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1694 <
1695 <        g.complete(v2);
1696 <        checkIncomplete(h);
1697 <        assertFalse(r.ran);
1698 <        f.complete(v1);
1699 <
1700 <        checkCompletedNormally(h, null);
1701 <        assertEquals(r.invocationCount, 1);
1702 <        checkCompletedNormally(f, v1);
1703 <        checkCompletedNormally(g, v2);
1704 <        }
1705 <    }
1692 >        final SubtractFunction r1 = new SubtractFunction(m);
1693 >        final SubtractFunction r2 = new SubtractFunction(m);
1694 >        final SubtractFunction r3 = new SubtractFunction(m);
1695 >
1696 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1697 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1698 >        final Callable<Boolean> complete1 = failFirst ?
1699 >            () -> fst.cancel(mayInterruptIfRunning) :
1700 >            () -> fst.complete(v1);
1701 >        final Callable<Boolean> complete2 = failFirst ?
1702 >            () -> snd.complete(v1) :
1703 >            () -> snd.cancel(mayInterruptIfRunning);
1704 >
1705 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1706 >        assertTrue(complete1.call());
1707 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1708 >        checkIncomplete(h1);
1709 >        checkIncomplete(h2);
1710 >        assertTrue(complete2.call());
1711 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1712 >
1713 >        checkCompletedWithWrappedCancellationException(h1);
1714 >        checkCompletedWithWrappedCancellationException(h2);
1715 >        checkCompletedWithWrappedCancellationException(h3);
1716 >        r1.assertNotInvoked();
1717 >        r2.assertNotInvoked();
1718 >        r3.assertNotInvoked();
1719 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1720 >        checkCancelled(failFirst ? fst : snd);
1721 >    }}
1722  
1723 <    public void testRunAfterBoth_normalCompletion3() {
1723 >    /**
1724 >     * thenCombine result completes exceptionally if action does
1725 >     */
1726 >    public void testThenCombine_actionFailed() {
1727          for (ExecutionMode m : ExecutionMode.values())
1728 +        for (boolean fFirst : new boolean[] { true, false })
1729          for (Integer v1 : new Integer[] { 1, null })
1730 <        for (Integer v2 : new Integer[] { 2, null }) {
1731 <
1730 >        for (Integer v2 : new Integer[] { 2, null })
1731 >    {
1732          final CompletableFuture<Integer> f = new CompletableFuture<>();
1733          final CompletableFuture<Integer> g = new CompletableFuture<>();
1734 <        final Noop r = new Noop();
1734 >        final FailingBiFunction r1 = new FailingBiFunction(m);
1735 >        final FailingBiFunction r2 = new FailingBiFunction(m);
1736 >        final FailingBiFunction r3 = new FailingBiFunction(m);
1737  
1738 <        g.complete(v2);
1739 <        f.complete(v1);
1740 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1738 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1739 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1740 >        final Integer w1 =  fFirst ? v1 : v2;
1741 >        final Integer w2 = !fFirst ? v1 : v2;
1742  
1743 <        checkCompletedNormally(h, null);
1744 <        assertTrue(r.ran);
1743 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1744 >        assertTrue(fst.complete(w1));
1745 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1746 >        assertTrue(snd.complete(w2));
1747 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1748 >
1749 >        checkCompletedWithWrappedCFException(h1);
1750 >        checkCompletedWithWrappedCFException(h2);
1751 >        checkCompletedWithWrappedCFException(h3);
1752 >        r1.assertInvoked();
1753 >        r2.assertInvoked();
1754 >        r3.assertInvoked();
1755          checkCompletedNormally(f, v1);
1756          checkCompletedNormally(g, v2);
1757 <        }
1615 <    }
1757 >    }}
1758  
1759 <    public void testRunAfterBoth_normalCompletion4() {
1759 >    /**
1760 >     * thenAcceptBoth result completes normally after normal
1761 >     * completion of sources
1762 >     */
1763 >    public void testThenAcceptBoth_normalCompletion() {
1764          for (ExecutionMode m : ExecutionMode.values())
1765 +        for (boolean fFirst : new boolean[] { true, false })
1766          for (Integer v1 : new Integer[] { 1, null })
1767 <        for (Integer v2 : new Integer[] { 2, null }) {
1768 <
1767 >        for (Integer v2 : new Integer[] { 2, null })
1768 >    {
1769          final CompletableFuture<Integer> f = new CompletableFuture<>();
1770          final CompletableFuture<Integer> g = new CompletableFuture<>();
1771 <        final Noop r = new Noop();
1772 <
1773 <        f.complete(v1);
1774 <        g.complete(v2);
1775 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1776 <
1777 <        checkCompletedNormally(h, null);
1778 <        assertEquals(r.invocationCount, 1);
1771 >        final SubtractAction r1 = new SubtractAction(m);
1772 >        final SubtractAction r2 = new SubtractAction(m);
1773 >        final SubtractAction r3 = new SubtractAction(m);
1774 >
1775 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1776 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1777 >        final Integer w1 =  fFirst ? v1 : v2;
1778 >        final Integer w2 = !fFirst ? v1 : v2;
1779 >
1780 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1781 >        assertTrue(fst.complete(w1));
1782 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1783 >        checkIncomplete(h1);
1784 >        checkIncomplete(h2);
1785 >        r1.assertNotInvoked();
1786 >        r2.assertNotInvoked();
1787 >        assertTrue(snd.complete(w2));
1788 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1789 >
1790 >        checkCompletedNormally(h1, null);
1791 >        checkCompletedNormally(h2, null);
1792 >        checkCompletedNormally(h3, null);
1793 >        r1.assertValue(subtract(v1, v2));
1794 >        r2.assertValue(subtract(v1, v2));
1795 >        r3.assertValue(subtract(v1, v2));
1796          checkCompletedNormally(f, v1);
1797          checkCompletedNormally(g, v2);
1798 <        }
1635 <    }
1798 >    }}
1799  
1800      /**
1801 <     * runAfterBoth result completes exceptionally after exceptional
1801 >     * thenAcceptBoth result completes exceptionally after exceptional
1802       * completion of either source
1803       */
1804 <    public void testRunAfterBoth_exceptionalCompletion1() {
1804 >    public void testThenAcceptBoth_exceptionalCompletion() throws Throwable {
1805          for (ExecutionMode m : ExecutionMode.values())
1806 <        for (Integer v1 : new Integer[] { 1, null }) {
1807 <
1806 >        for (boolean fFirst : new boolean[] { true, false })
1807 >        for (boolean failFirst : new boolean[] { true, false })
1808 >        for (Integer v1 : new Integer[] { 1, null })
1809 >    {
1810          final CompletableFuture<Integer> f = new CompletableFuture<>();
1811          final CompletableFuture<Integer> g = new CompletableFuture<>();
1647        final Noop r = new Noop();
1648        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1812          final CFException ex = new CFException();
1813 +        final SubtractAction r1 = new SubtractAction(m);
1814 +        final SubtractAction r2 = new SubtractAction(m);
1815 +        final SubtractAction r3 = new SubtractAction(m);
1816 +
1817 +        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1818 +        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1819 +        final Callable<Boolean> complete1 = failFirst ?
1820 +            () -> fst.completeExceptionally(ex) :
1821 +            () -> fst.complete(v1);
1822 +        final Callable<Boolean> complete2 = failFirst ?
1823 +            () -> snd.complete(v1) :
1824 +            () -> snd.completeExceptionally(ex);
1825 +
1826 +        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1827 +        assertTrue(complete1.call());
1828 +        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1829 +        checkIncomplete(h1);
1830 +        checkIncomplete(h2);
1831 +        assertTrue(complete2.call());
1832 +        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1833 +
1834 +        checkCompletedWithWrappedException(h1, ex);
1835 +        checkCompletedWithWrappedException(h2, ex);
1836 +        checkCompletedWithWrappedException(h3, ex);
1837 +        r1.assertNotInvoked();
1838 +        r2.assertNotInvoked();
1839 +        r3.assertNotInvoked();
1840 +        checkCompletedNormally(failFirst ? snd : fst, v1);
1841 +        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1842 +    }}
1843  
1844 <        f.completeExceptionally(ex);
1845 <        checkIncomplete(h);
1846 <        g.complete(v1);
1847 <
1655 <        checkCompletedWithWrappedCFException(h, ex);
1656 <        checkCompletedWithWrappedCFException(f, ex);
1657 <        assertEquals(r.invocationCount, 0);
1658 <        checkCompletedNormally(g, v1);
1659 <        }
1660 <    }
1661 <
1662 <    public void testRunAfterBoth_exceptionalCompletion2() {
1844 >    /**
1845 >     * thenAcceptBoth result completes exceptionally if either source cancelled
1846 >     */
1847 >    public void testThenAcceptBoth_sourceCancelled() throws Throwable {
1848          for (ExecutionMode m : ExecutionMode.values())
1849 <        for (Integer v1 : new Integer[] { 1, null }) {
1850 <
1849 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1850 >        for (boolean fFirst : new boolean[] { true, false })
1851 >        for (boolean failFirst : new boolean[] { true, false })
1852 >        for (Integer v1 : new Integer[] { 1, null })
1853 >    {
1854          final CompletableFuture<Integer> f = new CompletableFuture<>();
1855          final CompletableFuture<Integer> g = new CompletableFuture<>();
1856 <        final Noop r = new Noop();
1857 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1858 <        final CFException ex = new CFException();
1859 <
1860 <        g.completeExceptionally(ex);
1861 <        checkIncomplete(h);
1862 <        f.complete(v1);
1863 <
1864 <        checkCompletedWithWrappedCFException(h, ex);
1865 <        checkCompletedWithWrappedCFException(g, ex);
1866 <        assertEquals(r.invocationCount, 0);
1867 <        checkCompletedNormally(f, v1);
1868 <        }
1869 <    }
1856 >        final SubtractAction r1 = new SubtractAction(m);
1857 >        final SubtractAction r2 = new SubtractAction(m);
1858 >        final SubtractAction r3 = new SubtractAction(m);
1859 >
1860 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1861 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1862 >        final Callable<Boolean> complete1 = failFirst ?
1863 >            () -> fst.cancel(mayInterruptIfRunning) :
1864 >            () -> fst.complete(v1);
1865 >        final Callable<Boolean> complete2 = failFirst ?
1866 >            () -> snd.complete(v1) :
1867 >            () -> snd.cancel(mayInterruptIfRunning);
1868 >
1869 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1870 >        assertTrue(complete1.call());
1871 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1872 >        checkIncomplete(h1);
1873 >        checkIncomplete(h2);
1874 >        assertTrue(complete2.call());
1875 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1876 >
1877 >        checkCompletedWithWrappedCancellationException(h1);
1878 >        checkCompletedWithWrappedCancellationException(h2);
1879 >        checkCompletedWithWrappedCancellationException(h3);
1880 >        r1.assertNotInvoked();
1881 >        r2.assertNotInvoked();
1882 >        r3.assertNotInvoked();
1883 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1884 >        checkCancelled(failFirst ? fst : snd);
1885 >    }}
1886  
1887 <    public void testRunAfterBoth_exceptionalCompletion3() {
1887 >    /**
1888 >     * thenAcceptBoth result completes exceptionally if action does
1889 >     */
1890 >    public void testThenAcceptBoth_actionFailed() {
1891          for (ExecutionMode m : ExecutionMode.values())
1892 <        for (Integer v1 : new Integer[] { 1, null }) {
1893 <
1892 >        for (boolean fFirst : new boolean[] { true, false })
1893 >        for (Integer v1 : new Integer[] { 1, null })
1894 >        for (Integer v2 : new Integer[] { 2, null })
1895 >    {
1896          final CompletableFuture<Integer> f = new CompletableFuture<>();
1897          final CompletableFuture<Integer> g = new CompletableFuture<>();
1898 <        final Noop r = new Noop();
1899 <        final CFException ex = new CFException();
1900 <
1692 <        g.completeExceptionally(ex);
1693 <        f.complete(v1);
1694 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1898 >        final FailingBiConsumer r1 = new FailingBiConsumer(m);
1899 >        final FailingBiConsumer r2 = new FailingBiConsumer(m);
1900 >        final FailingBiConsumer r3 = new FailingBiConsumer(m);
1901  
1902 <        checkCompletedWithWrappedCFException(h, ex);
1903 <        checkCompletedWithWrappedCFException(g, ex);
1904 <        assertEquals(r.invocationCount, 0);
1905 <        checkCompletedNormally(f, v1);
1700 <        }
1701 <    }
1902 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1903 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1904 >        final Integer w1 =  fFirst ? v1 : v2;
1905 >        final Integer w2 = !fFirst ? v1 : v2;
1906  
1907 <    public void testRunAfterBoth_exceptionalCompletion4() {
1908 <        for (ExecutionMode m : ExecutionMode.values())
1909 <        for (Integer v1 : new Integer[] { 1, null }) {
1907 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1908 >        assertTrue(fst.complete(w1));
1909 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1910 >        assertTrue(snd.complete(w2));
1911 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1912  
1913 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1914 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1915 <        final Noop r = new Noop();
1916 <        final CFException ex = new CFException();
1917 <
1918 <        f.completeExceptionally(ex);
1919 <        g.complete(v1);
1920 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1921 <
1716 <        checkCompletedWithWrappedCFException(h, ex);
1717 <        checkCompletedWithWrappedCFException(f, ex);
1718 <        assertEquals(r.invocationCount, 0);
1719 <        checkCompletedNormally(g, v1);
1720 <        }
1721 <    }
1913 >        checkCompletedWithWrappedCFException(h1);
1914 >        checkCompletedWithWrappedCFException(h2);
1915 >        checkCompletedWithWrappedCFException(h3);
1916 >        r1.assertInvoked();
1917 >        r2.assertInvoked();
1918 >        r3.assertInvoked();
1919 >        checkCompletedNormally(f, v1);
1920 >        checkCompletedNormally(g, v2);
1921 >    }}
1922  
1923      /**
1924 <     * runAfterBoth result completes exceptionally if action does
1924 >     * runAfterBoth result completes normally after normal
1925 >     * completion of sources
1926       */
1927 <    public void testRunAfterBoth_actionFailed1() {
1927 >    public void testRunAfterBoth_normalCompletion() {
1928          for (ExecutionMode m : ExecutionMode.values())
1929 +        for (boolean fFirst : new boolean[] { true, false })
1930          for (Integer v1 : new Integer[] { 1, null })
1931 <        for (Integer v2 : new Integer[] { 2, null }) {
1932 <
1931 >        for (Integer v2 : new Integer[] { 2, null })
1932 >    {
1933          final CompletableFuture<Integer> f = new CompletableFuture<>();
1934          final CompletableFuture<Integer> g = new CompletableFuture<>();
1935 <        final FailingNoop r = new FailingNoop();
1936 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1937 <
1938 <        f.complete(v1);
1939 <        checkIncomplete(h);
1940 <        g.complete(v2);
1941 <
1942 <        checkCompletedWithWrappedCFException(h);
1935 >        final Noop r1 = new Noop(m);
1936 >        final Noop r2 = new Noop(m);
1937 >        final Noop r3 = new Noop(m);
1938 >
1939 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1940 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1941 >        final Integer w1 =  fFirst ? v1 : v2;
1942 >        final Integer w2 = !fFirst ? v1 : v2;
1943 >
1944 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1945 >        assertTrue(fst.complete(w1));
1946 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1947 >        checkIncomplete(h1);
1948 >        checkIncomplete(h2);
1949 >        r1.assertNotInvoked();
1950 >        r2.assertNotInvoked();
1951 >        assertTrue(snd.complete(w2));
1952 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
1953 >
1954 >        checkCompletedNormally(h1, null);
1955 >        checkCompletedNormally(h2, null);
1956 >        checkCompletedNormally(h3, null);
1957 >        r1.assertInvoked();
1958 >        r2.assertInvoked();
1959 >        r3.assertInvoked();
1960          checkCompletedNormally(f, v1);
1961          checkCompletedNormally(g, v2);
1962 <        }
1744 <    }
1962 >    }}
1963  
1964 <    public void testRunAfterBoth_actionFailed2() {
1964 >    /**
1965 >     * runAfterBoth result completes exceptionally after exceptional
1966 >     * completion of either source
1967 >     */
1968 >    public void testRunAfterBoth_exceptionalCompletion() throws Throwable {
1969          for (ExecutionMode m : ExecutionMode.values())
1970 +        for (boolean fFirst : new boolean[] { true, false })
1971 +        for (boolean failFirst : new boolean[] { true, false })
1972          for (Integer v1 : new Integer[] { 1, null })
1973 <        for (Integer v2 : new Integer[] { 2, null }) {
1750 <
1973 >    {
1974          final CompletableFuture<Integer> f = new CompletableFuture<>();
1975          final CompletableFuture<Integer> g = new CompletableFuture<>();
1976 <        final FailingNoop r = new FailingNoop();
1977 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1978 <
1979 <        g.complete(v2);
1980 <        checkIncomplete(h);
1981 <        f.complete(v1);
1982 <
1983 <        checkCompletedWithWrappedCFException(h);
1984 <        checkCompletedNormally(f, v1);
1985 <        checkCompletedNormally(g, v2);
1986 <        }
1987 <    }
1976 >        final CFException ex = new CFException();
1977 >        final Noop r1 = new Noop(m);
1978 >        final Noop r2 = new Noop(m);
1979 >        final Noop r3 = new Noop(m);
1980 >
1981 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1982 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1983 >        final Callable<Boolean> complete1 = failFirst ?
1984 >            () -> fst.completeExceptionally(ex) :
1985 >            () -> fst.complete(v1);
1986 >        final Callable<Boolean> complete2 = failFirst ?
1987 >            () -> snd.complete(v1) :
1988 >            () -> snd.completeExceptionally(ex);
1989 >
1990 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1991 >        assertTrue(complete1.call());
1992 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1993 >        checkIncomplete(h1);
1994 >        checkIncomplete(h2);
1995 >        assertTrue(complete2.call());
1996 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
1997 >
1998 >        checkCompletedWithWrappedException(h1, ex);
1999 >        checkCompletedWithWrappedException(h2, ex);
2000 >        checkCompletedWithWrappedException(h3, ex);
2001 >        r1.assertNotInvoked();
2002 >        r2.assertNotInvoked();
2003 >        r3.assertNotInvoked();
2004 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2005 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
2006 >    }}
2007  
2008      /**
2009       * runAfterBoth result completes exceptionally if either source cancelled
2010       */
2011 <    public void testRunAfterBoth_sourceCancelled1() {
2011 >    public void testRunAfterBoth_sourceCancelled() throws Throwable {
2012          for (ExecutionMode m : ExecutionMode.values())
2013          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2014 <        for (Integer v1 : new Integer[] { 1, null }) {
2015 <
2014 >        for (boolean fFirst : new boolean[] { true, false })
2015 >        for (boolean failFirst : new boolean[] { true, false })
2016 >        for (Integer v1 : new Integer[] { 1, null })
2017 >    {
2018          final CompletableFuture<Integer> f = new CompletableFuture<>();
2019          final CompletableFuture<Integer> g = new CompletableFuture<>();
2020 <        final Noop r = new Noop();
2021 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2022 <
2023 <        assertTrue(f.cancel(mayInterruptIfRunning));
2024 <        checkIncomplete(h);
2025 <        g.complete(v1);
2020 >        final Noop r1 = new Noop(m);
2021 >        final Noop r2 = new Noop(m);
2022 >        final Noop r3 = new Noop(m);
2023 >
2024 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2025 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2026 >        final Callable<Boolean> complete1 = failFirst ?
2027 >            () -> fst.cancel(mayInterruptIfRunning) :
2028 >            () -> fst.complete(v1);
2029 >        final Callable<Boolean> complete2 = failFirst ?
2030 >            () -> snd.complete(v1) :
2031 >            () -> snd.cancel(mayInterruptIfRunning);
2032 >
2033 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2034 >        assertTrue(complete1.call());
2035 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2036 >        checkIncomplete(h1);
2037 >        checkIncomplete(h2);
2038 >        assertTrue(complete2.call());
2039 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2040 >
2041 >        checkCompletedWithWrappedCancellationException(h1);
2042 >        checkCompletedWithWrappedCancellationException(h2);
2043 >        checkCompletedWithWrappedCancellationException(h3);
2044 >        r1.assertNotInvoked();
2045 >        r2.assertNotInvoked();
2046 >        r3.assertNotInvoked();
2047 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2048 >        checkCancelled(failFirst ? fst : snd);
2049 >    }}
2050  
2051 <        checkCompletedWithWrappedCancellationException(h);
2052 <        checkCancelled(f);
2053 <        assertEquals(r.invocationCount, 0);
2054 <        checkCompletedNormally(g, v1);
1787 <        }
1788 <    }
1789 <
1790 <    public void testRunAfterBoth_sourceCancelled2() {
2051 >    /**
2052 >     * runAfterBoth result completes exceptionally if action does
2053 >     */
2054 >    public void testRunAfterBoth_actionFailed() {
2055          for (ExecutionMode m : ExecutionMode.values())
2056 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2057 <        for (Integer v1 : new Integer[] { 1, null }) {
2058 <
2056 >        for (boolean fFirst : new boolean[] { true, false })
2057 >        for (Integer v1 : new Integer[] { 1, null })
2058 >        for (Integer v2 : new Integer[] { 2, null })
2059 >    {
2060          final CompletableFuture<Integer> f = new CompletableFuture<>();
2061          final CompletableFuture<Integer> g = new CompletableFuture<>();
2062 <        final Noop r = new Noop();
2063 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2062 >        final FailingRunnable r1 = new FailingRunnable(m);
2063 >        final FailingRunnable r2 = new FailingRunnable(m);
2064 >        final FailingRunnable r3 = new FailingRunnable(m);
2065  
2066 <        assertTrue(g.cancel(mayInterruptIfRunning));
2067 <        checkIncomplete(h);
2068 <        f.complete(v1);
2066 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2067 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2068 >        final Integer w1 =  fFirst ? v1 : v2;
2069 >        final Integer w2 = !fFirst ? v1 : v2;
2070  
2071 <        checkCompletedWithWrappedCancellationException(h);
2072 <        checkCancelled(g);
2073 <        assertEquals(r.invocationCount, 0);
2074 <        checkCompletedNormally(f, v1);
2075 <        }
1809 <    }
1810 <
1811 <    public void testRunAfterBoth_sourceCancelled3() {
1812 <        for (ExecutionMode m : ExecutionMode.values())
1813 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1814 <        for (Integer v1 : new Integer[] { 1, null }) {
2071 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2072 >        assertTrue(fst.complete(w1));
2073 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2074 >        assertTrue(snd.complete(w2));
2075 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2076  
2077 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2078 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2079 <        final Noop r = new Noop();
2080 <
2081 <        assertTrue(g.cancel(mayInterruptIfRunning));
2082 <        f.complete(v1);
1822 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1823 <
1824 <        checkCompletedWithWrappedCancellationException(h);
1825 <        checkCancelled(g);
1826 <        assertEquals(r.invocationCount, 0);
2077 >        checkCompletedWithWrappedCFException(h1);
2078 >        checkCompletedWithWrappedCFException(h2);
2079 >        checkCompletedWithWrappedCFException(h3);
2080 >        r1.assertInvoked();
2081 >        r2.assertInvoked();
2082 >        r3.assertInvoked();
2083          checkCompletedNormally(f, v1);
2084 <        }
2085 <    }
1830 <
1831 <    public void testRunAfterBoth_sourceCancelled4() {
1832 <        for (ExecutionMode m : ExecutionMode.values())
1833 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1834 <        for (Integer v1 : new Integer[] { 1, null }) {
1835 <
1836 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1837 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1838 <        final Noop r = new Noop();
1839 <
1840 <        assertTrue(f.cancel(mayInterruptIfRunning));
1841 <        g.complete(v1);
1842 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1843 <
1844 <        checkCompletedWithWrappedCancellationException(h);
1845 <        checkCancelled(f);
1846 <        assertEquals(r.invocationCount, 0);
1847 <        checkCompletedNormally(g, v1);
1848 <        }
1849 <    }
2084 >        checkCompletedNormally(g, v2);
2085 >    }}
2086  
2087      /**
2088       * applyToEither result completes normally after normal completion
2089       * of either source
2090       */
2091 <    public void testApplyToEither_normalCompletion1() {
2091 >    public void testApplyToEither_normalCompletion() {
2092          for (ExecutionMode m : ExecutionMode.values())
2093          for (Integer v1 : new Integer[] { 1, null })
2094 <        for (Integer v2 : new Integer[] { 2, null }) {
2095 <
2094 >        for (Integer v2 : new Integer[] { 2, null })
2095 >    {
2096          final CompletableFuture<Integer> f = new CompletableFuture<>();
2097          final CompletableFuture<Integer> g = new CompletableFuture<>();
2098 <        final IncFunction r = new IncFunction();
2099 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2098 >        final IncFunction[] rs = new IncFunction[6];
2099 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2100  
2101 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2102 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2103 +        checkIncomplete(h0);
2104 +        checkIncomplete(h1);
2105 +        rs[0].assertNotInvoked();
2106 +        rs[1].assertNotInvoked();
2107          f.complete(v1);
2108 <        checkCompletedNormally(h, inc(v1));
2108 >        checkCompletedNormally(h0, inc(v1));
2109 >        checkCompletedNormally(h1, inc(v1));
2110 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2111 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2112 >        checkCompletedNormally(h2, inc(v1));
2113 >        checkCompletedNormally(h3, inc(v1));
2114          g.complete(v2);
2115  
2116 <        checkCompletedNormally(f, v1);
2117 <        checkCompletedNormally(g, v2);
2118 <        checkCompletedNormally(h, inc(v1));
2119 <        }
2120 <    }
2121 <
2122 <    public void testApplyToEither_normalCompletion2() {
2123 <        for (ExecutionMode m : ExecutionMode.values())
2124 <        for (Integer v1 : new Integer[] { 1, null })
1878 <        for (Integer v2 : new Integer[] { 2, null }) {
1879 <
1880 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1881 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1882 <        final IncFunction r = new IncFunction();
1883 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1884 <
1885 <        g.complete(v2);
1886 <        checkCompletedNormally(h, inc(v2));
1887 <        f.complete(v1);
1888 <
1889 <        checkCompletedNormally(f, v1);
1890 <        checkCompletedNormally(g, v2);
1891 <        checkCompletedNormally(h, inc(v2));
1892 <        }
1893 <    }
1894 <    public void testApplyToEither_normalCompletion3() {
1895 <        for (ExecutionMode m : ExecutionMode.values())
1896 <        for (Integer v1 : new Integer[] { 1, null })
1897 <        for (Integer v2 : new Integer[] { 2, null }) {
1898 <
1899 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1900 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1901 <        final IncFunction r = new IncFunction();
1902 <
1903 <        f.complete(v1);
1904 <        g.complete(v2);
1905 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2116 >        // unspecified behavior - both source completions available
2117 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2118 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2119 >        rs[4].assertValue(h4.join());
2120 >        rs[5].assertValue(h5.join());
2121 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
2122 >                   Objects.equals(inc(v2), h4.join()));
2123 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
2124 >                   Objects.equals(inc(v2), h5.join()));
2125  
2126          checkCompletedNormally(f, v1);
2127          checkCompletedNormally(g, v2);
2128 <
2129 <        // unspecified behavior
2130 <        assertTrue(Objects.equals(h.join(), inc(v1)) ||
2131 <                   Objects.equals(h.join(), inc(v2)));
2132 <        assertEquals(r.invocationCount, 1);
2133 <        }
1915 <    }
2128 >        checkCompletedNormally(h0, inc(v1));
2129 >        checkCompletedNormally(h1, inc(v1));
2130 >        checkCompletedNormally(h2, inc(v1));
2131 >        checkCompletedNormally(h3, inc(v1));
2132 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
2133 >    }}
2134  
2135      /**
2136       * applyToEither result completes exceptionally after exceptional
2137       * completion of either source
2138       */
2139 <    public void testApplyToEither_exceptionalCompletion1() {
2139 >    public void testApplyToEither_exceptionalCompletion() {
2140          for (ExecutionMode m : ExecutionMode.values())
2141 <        for (Integer v1 : new Integer[] { 1, null }) {
2142 <
2141 >        for (Integer v1 : new Integer[] { 1, null })
2142 >    {
2143          final CompletableFuture<Integer> f = new CompletableFuture<>();
2144          final CompletableFuture<Integer> g = new CompletableFuture<>();
1927        final IncFunction r = new IncFunction();
1928        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2145          final CFException ex = new CFException();
2146 +        final IncFunction[] rs = new IncFunction[6];
2147 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2148  
2149 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2150 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2151 +        checkIncomplete(h0);
2152 +        checkIncomplete(h1);
2153 +        rs[0].assertNotInvoked();
2154 +        rs[1].assertNotInvoked();
2155          f.completeExceptionally(ex);
2156 <        checkCompletedWithWrappedCFException(h, ex);
2156 >        checkCompletedWithWrappedException(h0, ex);
2157 >        checkCompletedWithWrappedException(h1, ex);
2158 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2159 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2160 >        checkCompletedWithWrappedException(h2, ex);
2161 >        checkCompletedWithWrappedException(h3, ex);
2162          g.complete(v1);
2163  
2164 <        assertEquals(r.invocationCount, 0);
2165 <        checkCompletedNormally(g, v1);
2166 <        checkCompletedWithWrappedCFException(f, ex);
2167 <        checkCompletedWithWrappedCFException(h, ex);
2168 <        }
2169 <    }
2170 <
2171 <    public void testApplyToEither_exceptionalCompletion2() {
2172 <        for (ExecutionMode m : ExecutionMode.values())
1944 <        for (Integer v1 : new Integer[] { 1, null }) {
1945 <
1946 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1947 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1948 <        final IncFunction r = new IncFunction();
1949 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1950 <        final CFException ex = new CFException();
1951 <
1952 <        g.completeExceptionally(ex);
1953 <        checkCompletedWithWrappedCFException(h, ex);
1954 <        f.complete(v1);
1955 <
1956 <        assertEquals(r.invocationCount, 0);
1957 <        checkCompletedNormally(f, v1);
1958 <        checkCompletedWithWrappedCFException(g, ex);
1959 <        checkCompletedWithWrappedCFException(h, ex);
2164 >        // unspecified behavior - both source completions available
2165 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2166 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2167 >        try {
2168 >            assertEquals(inc(v1), h4.join());
2169 >            rs[4].assertValue(inc(v1));
2170 >        } catch (CompletionException ok) {
2171 >            checkCompletedWithWrappedException(h4, ex);
2172 >            rs[4].assertNotInvoked();
2173          }
1961    }
1962
1963    public void testApplyToEither_exceptionalCompletion3() {
1964        for (ExecutionMode m : ExecutionMode.values())
1965        for (Integer v1 : new Integer[] { 1, null }) {
1966
1967        final CompletableFuture<Integer> f = new CompletableFuture<>();
1968        final CompletableFuture<Integer> g = new CompletableFuture<>();
1969        final IncFunction r = new IncFunction();
1970        final CFException ex = new CFException();
1971
1972        g.completeExceptionally(ex);
1973        f.complete(v1);
1974        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1975
1976        // unspecified behavior
1977        Integer v;
2174          try {
2175 <            assertEquals(h.join(), inc(v1));
2176 <            assertEquals(r.invocationCount, 1);
2175 >            assertEquals(inc(v1), h5.join());
2176 >            rs[5].assertValue(inc(v1));
2177          } catch (CompletionException ok) {
2178 <            checkCompletedWithWrappedCFException(h, ex);
2179 <            assertEquals(r.invocationCount, 0);
2178 >            checkCompletedWithWrappedException(h5, ex);
2179 >            rs[5].assertNotInvoked();
2180          }
2181  
2182 <        checkCompletedWithWrappedCFException(g, ex);
2183 <        checkCompletedNormally(f, v1);
2184 <        }
2185 <    }
2182 >        checkCompletedExceptionally(f, ex);
2183 >        checkCompletedNormally(g, v1);
2184 >        checkCompletedWithWrappedException(h0, ex);
2185 >        checkCompletedWithWrappedException(h1, ex);
2186 >        checkCompletedWithWrappedException(h2, ex);
2187 >        checkCompletedWithWrappedException(h3, ex);
2188 >        checkCompletedWithWrappedException(h4, ex);
2189 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2190 >    }}
2191  
2192 <    public void testApplyToEither_exceptionalCompletion4() {
2192 >    public void testApplyToEither_exceptionalCompletion2() {
2193          for (ExecutionMode m : ExecutionMode.values())
2194 <        for (Integer v1 : new Integer[] { 1, null }) {
2195 <
2194 >        for (boolean fFirst : new boolean[] { true, false })
2195 >        for (Integer v1 : new Integer[] { 1, null })
2196 >    {
2197          final CompletableFuture<Integer> f = new CompletableFuture<>();
2198          final CompletableFuture<Integer> g = new CompletableFuture<>();
1997        final IncFunction r = new IncFunction();
2199          final CFException ex = new CFException();
2200 +        final IncFunction[] rs = new IncFunction[6];
2201 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2202  
2203 <        f.completeExceptionally(ex);
2204 <        g.complete(v1);
2205 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2203 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2204 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2205 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2206 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2207 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2208 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2209  
2210 <        // unspecified behavior
2005 <        Integer v;
2210 >        // unspecified behavior - both source completions available
2211          try {
2212 <            assertEquals(h.join(), inc(v1));
2213 <            assertEquals(r.invocationCount, 1);
2212 >            assertEquals(inc(v1), h0.join());
2213 >            rs[0].assertValue(inc(v1));
2214          } catch (CompletionException ok) {
2215 <            checkCompletedWithWrappedCFException(h, ex);
2216 <            assertEquals(r.invocationCount, 0);
2215 >            checkCompletedWithWrappedException(h0, ex);
2216 >            rs[0].assertNotInvoked();
2217          }
2218 <
2219 <        checkCompletedWithWrappedCFException(f, ex);
2220 <        checkCompletedNormally(g, v1);
2218 >        try {
2219 >            assertEquals(inc(v1), h1.join());
2220 >            rs[1].assertValue(inc(v1));
2221 >        } catch (CompletionException ok) {
2222 >            checkCompletedWithWrappedException(h1, ex);
2223 >            rs[1].assertNotInvoked();
2224          }
2225 <    }
2226 <
2227 <    /**
2228 <     * applyToEither result completes exceptionally if action does
2229 <     */
2230 <    public void testApplyToEither_actionFailed1() {
2231 <        for (ExecutionMode m : ExecutionMode.values())
2232 <        for (Integer v1 : new Integer[] { 1, null })
2233 <        for (Integer v2 : new Integer[] { 2, null }) {
2234 <
2235 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2236 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2237 <        final FailingFunction r = new FailingFunction();
2030 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2031 <
2032 <        f.complete(v1);
2033 <        checkCompletedWithWrappedCFException(h);
2034 <        g.complete(v2);
2035 <        checkCompletedNormally(f, v1);
2036 <        checkCompletedNormally(g, v2);
2225 >        try {
2226 >            assertEquals(inc(v1), h2.join());
2227 >            rs[2].assertValue(inc(v1));
2228 >        } catch (CompletionException ok) {
2229 >            checkCompletedWithWrappedException(h2, ex);
2230 >            rs[2].assertNotInvoked();
2231 >        }
2232 >        try {
2233 >            assertEquals(inc(v1), h3.join());
2234 >            rs[3].assertValue(inc(v1));
2235 >        } catch (CompletionException ok) {
2236 >            checkCompletedWithWrappedException(h3, ex);
2237 >            rs[3].assertNotInvoked();
2238          }
2038    }
2039
2040    public void testApplyToEither_actionFailed2() {
2041        for (ExecutionMode m : ExecutionMode.values())
2042        for (Integer v1 : new Integer[] { 1, null })
2043        for (Integer v2 : new Integer[] { 2, null }) {
2044
2045        final CompletableFuture<Integer> f = new CompletableFuture<>();
2046        final CompletableFuture<Integer> g = new CompletableFuture<>();
2047        final FailingFunction r = new FailingFunction();
2048        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2239  
2050        g.complete(v2);
2051        checkCompletedWithWrappedCFException(h);
2052        f.complete(v1);
2240          checkCompletedNormally(f, v1);
2241 <        checkCompletedNormally(g, v2);
2242 <        }
2056 <    }
2241 >        checkCompletedExceptionally(g, ex);
2242 >    }}
2243  
2244      /**
2245       * applyToEither result completes exceptionally if either source cancelled
2246       */
2247 <    public void testApplyToEither_sourceCancelled1() {
2247 >    public void testApplyToEither_sourceCancelled() {
2248          for (ExecutionMode m : ExecutionMode.values())
2249          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2250 <        for (Integer v1 : new Integer[] { 1, null }) {
2251 <
2250 >        for (Integer v1 : new Integer[] { 1, null })
2251 >    {
2252          final CompletableFuture<Integer> f = new CompletableFuture<>();
2253          final CompletableFuture<Integer> g = new CompletableFuture<>();
2254 <        final IncFunction r = new IncFunction();
2255 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2254 >        final IncFunction[] rs = new IncFunction[6];
2255 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2256  
2257 <        assertTrue(f.cancel(mayInterruptIfRunning));
2258 <        checkCompletedWithWrappedCancellationException(h);
2257 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2258 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2259 >        checkIncomplete(h0);
2260 >        checkIncomplete(h1);
2261 >        rs[0].assertNotInvoked();
2262 >        rs[1].assertNotInvoked();
2263 >        f.cancel(mayInterruptIfRunning);
2264 >        checkCompletedWithWrappedCancellationException(h0);
2265 >        checkCompletedWithWrappedCancellationException(h1);
2266 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2267 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2268 >        checkCompletedWithWrappedCancellationException(h2);
2269 >        checkCompletedWithWrappedCancellationException(h3);
2270          g.complete(v1);
2271  
2272 +        // unspecified behavior - both source completions available
2273 +        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2274 +        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2275 +        try {
2276 +            assertEquals(inc(v1), h4.join());
2277 +            rs[4].assertValue(inc(v1));
2278 +        } catch (CompletionException ok) {
2279 +            checkCompletedWithWrappedCancellationException(h4);
2280 +            rs[4].assertNotInvoked();
2281 +        }
2282 +        try {
2283 +            assertEquals(inc(v1), h5.join());
2284 +            rs[5].assertValue(inc(v1));
2285 +        } catch (CompletionException ok) {
2286 +            checkCompletedWithWrappedCancellationException(h5);
2287 +            rs[5].assertNotInvoked();
2288 +        }
2289 +
2290          checkCancelled(f);
2076        assertEquals(r.invocationCount, 0);
2291          checkCompletedNormally(g, v1);
2292 <        checkCompletedWithWrappedCancellationException(h);
2293 <        }
2294 <    }
2292 >        checkCompletedWithWrappedCancellationException(h0);
2293 >        checkCompletedWithWrappedCancellationException(h1);
2294 >        checkCompletedWithWrappedCancellationException(h2);
2295 >        checkCompletedWithWrappedCancellationException(h3);
2296 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2297 >    }}
2298  
2299      public void testApplyToEither_sourceCancelled2() {
2300          for (ExecutionMode m : ExecutionMode.values())
2301          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2302 <        for (Integer v1 : new Integer[] { 1, null }) {
2303 <
2302 >        for (boolean fFirst : new boolean[] { true, false })
2303 >        for (Integer v1 : new Integer[] { 1, null })
2304 >    {
2305          final CompletableFuture<Integer> f = new CompletableFuture<>();
2306          final CompletableFuture<Integer> g = new CompletableFuture<>();
2307 <        final IncFunction r = new IncFunction();
2308 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2307 >        final IncFunction[] rs = new IncFunction[6];
2308 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2309  
2310 <        assertTrue(g.cancel(mayInterruptIfRunning));
2311 <        checkCompletedWithWrappedCancellationException(h);
2312 <        f.complete(v1);
2310 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2311 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2312 >        assertTrue(fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2313 >        assertTrue(!fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2314 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2315 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2316  
2317 <        checkCancelled(g);
2318 <        assertEquals(r.invocationCount, 0);
2319 <        checkCompletedNormally(f, v1);
2320 <        checkCompletedWithWrappedCancellationException(h);
2317 >        // unspecified behavior - both source completions available
2318 >        try {
2319 >            assertEquals(inc(v1), h0.join());
2320 >            rs[0].assertValue(inc(v1));
2321 >        } catch (CompletionException ok) {
2322 >            checkCompletedWithWrappedCancellationException(h0);
2323 >            rs[0].assertNotInvoked();
2324          }
2101    }
2102
2103    public void testApplyToEither_sourceCancelled3() {
2104        for (ExecutionMode m : ExecutionMode.values())
2105        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2106        for (Integer v1 : new Integer[] { 1, null }) {
2107
2108        final CompletableFuture<Integer> f = new CompletableFuture<>();
2109        final CompletableFuture<Integer> g = new CompletableFuture<>();
2110        final IncFunction r = new IncFunction();
2111
2112        assertTrue(g.cancel(mayInterruptIfRunning));
2113        f.complete(v1);
2114        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2115
2116        // unspecified behavior
2117        Integer v;
2325          try {
2326 <            assertEquals(h.join(), inc(v1));
2327 <            assertEquals(r.invocationCount, 1);
2326 >            assertEquals(inc(v1), h1.join());
2327 >            rs[1].assertValue(inc(v1));
2328          } catch (CompletionException ok) {
2329 <            checkCompletedWithWrappedCancellationException(h);
2330 <            assertEquals(r.invocationCount, 0);
2329 >            checkCompletedWithWrappedCancellationException(h1);
2330 >            rs[1].assertNotInvoked();
2331          }
2332 <
2333 <        checkCancelled(g);
2334 <        checkCompletedNormally(f, v1);
2332 >        try {
2333 >            assertEquals(inc(v1), h2.join());
2334 >            rs[2].assertValue(inc(v1));
2335 >        } catch (CompletionException ok) {
2336 >            checkCompletedWithWrappedCancellationException(h2);
2337 >            rs[2].assertNotInvoked();
2338          }
2129    }
2130
2131    public void testApplyToEither_sourceCancelled4() {
2132        for (ExecutionMode m : ExecutionMode.values())
2133        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2134        for (Integer v1 : new Integer[] { 1, null }) {
2135
2136        final CompletableFuture<Integer> f = new CompletableFuture<>();
2137        final CompletableFuture<Integer> g = new CompletableFuture<>();
2138        final IncFunction r = new IncFunction();
2139
2140        assertTrue(f.cancel(mayInterruptIfRunning));
2141        g.complete(v1);
2142        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2143
2144        // unspecified behavior
2145        Integer v;
2339          try {
2340 <            assertEquals(h.join(), inc(v1));
2341 <            assertEquals(r.invocationCount, 1);
2340 >            assertEquals(inc(v1), h3.join());
2341 >            rs[3].assertValue(inc(v1));
2342          } catch (CompletionException ok) {
2343 <            checkCompletedWithWrappedCancellationException(h);
2344 <            assertEquals(r.invocationCount, 0);
2343 >            checkCompletedWithWrappedCancellationException(h3);
2344 >            rs[3].assertNotInvoked();
2345          }
2346  
2347 <        checkCancelled(f);
2348 <        checkCompletedNormally(g, v1);
2349 <        }
2157 <    }
2347 >        checkCompletedNormally(f, v1);
2348 >        checkCancelled(g);
2349 >    }}
2350  
2351      /**
2352 <     * acceptEither result completes normally after normal completion
2161 <     * of either source
2352 >     * applyToEither result completes exceptionally if action does
2353       */
2354 <    public void testAcceptEither_normalCompletion1() {
2354 >    public void testApplyToEither_actionFailed() {
2355          for (ExecutionMode m : ExecutionMode.values())
2356          for (Integer v1 : new Integer[] { 1, null })
2357 <        for (Integer v2 : new Integer[] { 2, null }) {
2358 <
2357 >        for (Integer v2 : new Integer[] { 2, null })
2358 >    {
2359          final CompletableFuture<Integer> f = new CompletableFuture<>();
2360          final CompletableFuture<Integer> g = new CompletableFuture<>();
2361 <        final IncAction r = new IncAction();
2362 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2361 >        final FailingFunction[] rs = new FailingFunction[6];
2362 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
2363  
2364 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2365 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2366          f.complete(v1);
2367 <        checkCompletedNormally(h, null);
2368 <        assertEquals(r.value, inc(v1));
2369 <        g.complete(v2);
2367 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2368 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2369 >        checkCompletedWithWrappedCFException(h0);
2370 >        checkCompletedWithWrappedCFException(h1);
2371 >        checkCompletedWithWrappedCFException(h2);
2372 >        checkCompletedWithWrappedCFException(h3);
2373 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2374  
2375 <        checkCompletedNormally(f, v1);
2179 <        checkCompletedNormally(g, v2);
2180 <        checkCompletedNormally(h, null);
2181 <        }
2182 <    }
2183 <
2184 <    public void testAcceptEither_normalCompletion2() {
2185 <        for (ExecutionMode m : ExecutionMode.values())
2186 <        for (Integer v1 : new Integer[] { 1, null })
2187 <        for (Integer v2 : new Integer[] { 2, null }) {
2375 >        g.complete(v2);
2376  
2377 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2378 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2379 <        final IncAction r = new IncAction();
2192 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2377 >        // unspecified behavior - both source completions available
2378 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2379 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2380  
2381 <        g.complete(v2);
2382 <        checkCompletedNormally(h, null);
2383 <        assertEquals(r.value, inc(v2));
2384 <        f.complete(v1);
2381 >        checkCompletedWithWrappedCFException(h4);
2382 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2383 >                   Objects.equals(v2, rs[4].value));
2384 >        checkCompletedWithWrappedCFException(h5);
2385 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2386 >                   Objects.equals(v2, rs[5].value));
2387  
2388          checkCompletedNormally(f, v1);
2389          checkCompletedNormally(g, v2);
2390 <        checkCompletedNormally(h, null);
2391 <        }
2392 <    }
2393 <    public void testAcceptEither_normalCompletion3() {
2390 >    }}
2391 >
2392 >    /**
2393 >     * acceptEither result completes normally after normal completion
2394 >     * of either source
2395 >     */
2396 >    public void testAcceptEither_normalCompletion() {
2397          for (ExecutionMode m : ExecutionMode.values())
2398          for (Integer v1 : new Integer[] { 1, null })
2399 <        for (Integer v2 : new Integer[] { 2, null }) {
2400 <
2399 >        for (Integer v2 : new Integer[] { 2, null })
2400 >    {
2401          final CompletableFuture<Integer> f = new CompletableFuture<>();
2402          final CompletableFuture<Integer> g = new CompletableFuture<>();
2403 <        final IncAction r = new IncAction();
2403 >        final NoopConsumer[] rs = new NoopConsumer[6];
2404 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2405 >
2406 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2407 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2408 >        checkIncomplete(h0);
2409 >        checkIncomplete(h1);
2410 >        rs[0].assertNotInvoked();
2411 >        rs[1].assertNotInvoked();
2412 >        f.complete(v1);
2413 >        checkCompletedNormally(h0, null);
2414 >        checkCompletedNormally(h1, null);
2415 >        rs[0].assertValue(v1);
2416 >        rs[1].assertValue(v1);
2417 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2418 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2419 >        checkCompletedNormally(h2, null);
2420 >        checkCompletedNormally(h3, null);
2421 >        rs[2].assertValue(v1);
2422 >        rs[3].assertValue(v1);
2423 >        g.complete(v2);
2424 >
2425 >        // unspecified behavior - both source completions available
2426 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2427 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2428 >        checkCompletedNormally(h4, null);
2429 >        checkCompletedNormally(h5, null);
2430 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2431 >                   Objects.equals(v2, rs[4].value));
2432 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2433 >                   Objects.equals(v2, rs[5].value));
2434  
2213        f.complete(v1);
2214        g.complete(v2);
2215        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2216
2217        checkCompletedNormally(h, null);
2435          checkCompletedNormally(f, v1);
2436          checkCompletedNormally(g, v2);
2437 <
2438 <        // unspecified behavior
2439 <        assertTrue(Objects.equals(r.value, inc(v1)) ||
2440 <                   Objects.equals(r.value, inc(v2)));
2441 <        }
2442 <    }
2437 >        checkCompletedNormally(h0, null);
2438 >        checkCompletedNormally(h1, null);
2439 >        checkCompletedNormally(h2, null);
2440 >        checkCompletedNormally(h3, null);
2441 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2442 >    }}
2443  
2444      /**
2445       * acceptEither result completes exceptionally after exceptional
2446       * completion of either source
2447       */
2448 <    public void testAcceptEither_exceptionalCompletion1() {
2448 >    public void testAcceptEither_exceptionalCompletion() {
2449          for (ExecutionMode m : ExecutionMode.values())
2450 <        for (Integer v1 : new Integer[] { 1, null }) {
2451 <
2450 >        for (Integer v1 : new Integer[] { 1, null })
2451 >    {
2452          final CompletableFuture<Integer> f = new CompletableFuture<>();
2453          final CompletableFuture<Integer> g = new CompletableFuture<>();
2237        final IncAction r = new IncAction();
2238        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2454          final CFException ex = new CFException();
2455 +        final NoopConsumer[] rs = new NoopConsumer[6];
2456 +        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2457  
2458 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2459 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2460 +        checkIncomplete(h0);
2461 +        checkIncomplete(h1);
2462 +        rs[0].assertNotInvoked();
2463 +        rs[1].assertNotInvoked();
2464          f.completeExceptionally(ex);
2465 <        checkCompletedWithWrappedCFException(h, ex);
2466 <        g.complete(v1);
2467 <
2468 <        assertEquals(r.invocationCount, 0);
2469 <        checkCompletedNormally(g, v1);
2470 <        checkCompletedWithWrappedCFException(f, ex);
2248 <        checkCompletedWithWrappedCFException(h, ex);
2249 <        }
2250 <    }
2251 <
2252 <    public void testAcceptEither_exceptionalCompletion2() {
2253 <        for (ExecutionMode m : ExecutionMode.values())
2254 <        for (Integer v1 : new Integer[] { 1, null }) {
2465 >        checkCompletedWithWrappedException(h0, ex);
2466 >        checkCompletedWithWrappedException(h1, ex);
2467 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2468 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2469 >        checkCompletedWithWrappedException(h2, ex);
2470 >        checkCompletedWithWrappedException(h3, ex);
2471  
2472 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2257 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2258 <        final IncAction r = new IncAction();
2259 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2260 <        final CFException ex = new CFException();
2261 <
2262 <        g.completeExceptionally(ex);
2263 <        checkCompletedWithWrappedCFException(h, ex);
2264 <        f.complete(v1);
2472 >        g.complete(v1);
2473  
2474 <        assertEquals(r.invocationCount, 0);
2475 <        checkCompletedNormally(f, v1);
2476 <        checkCompletedWithWrappedCFException(g, ex);
2477 <        checkCompletedWithWrappedCFException(h, ex);
2474 >        // unspecified behavior - both source completions available
2475 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2476 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2477 >        try {
2478 >            assertNull(h4.join());
2479 >            rs[4].assertValue(v1);
2480 >        } catch (CompletionException ok) {
2481 >            checkCompletedWithWrappedException(h4, ex);
2482 >            rs[4].assertNotInvoked();
2483          }
2271    }
2272
2273    public void testAcceptEither_exceptionalCompletion3() {
2274        for (ExecutionMode m : ExecutionMode.values())
2275        for (Integer v1 : new Integer[] { 1, null }) {
2276
2277        final CompletableFuture<Integer> f = new CompletableFuture<>();
2278        final CompletableFuture<Integer> g = new CompletableFuture<>();
2279        final IncAction r = new IncAction();
2280        final CFException ex = new CFException();
2281
2282        g.completeExceptionally(ex);
2283        f.complete(v1);
2284        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2285
2286        // unspecified behavior
2287        Integer v;
2484          try {
2485 <            assertEquals(h.join(), null);
2486 <            assertEquals(r.invocationCount, 1);
2291 <            assertEquals(inc(v1), r.value);
2485 >            assertNull(h5.join());
2486 >            rs[5].assertValue(v1);
2487          } catch (CompletionException ok) {
2488 <            checkCompletedWithWrappedCFException(h, ex);
2489 <            assertEquals(r.invocationCount, 0);
2488 >            checkCompletedWithWrappedException(h5, ex);
2489 >            rs[5].assertNotInvoked();
2490          }
2491  
2492 <        checkCompletedWithWrappedCFException(g, ex);
2493 <        checkCompletedNormally(f, v1);
2494 <        }
2495 <    }
2492 >        checkCompletedExceptionally(f, ex);
2493 >        checkCompletedNormally(g, v1);
2494 >        checkCompletedWithWrappedException(h0, ex);
2495 >        checkCompletedWithWrappedException(h1, ex);
2496 >        checkCompletedWithWrappedException(h2, ex);
2497 >        checkCompletedWithWrappedException(h3, ex);
2498 >        checkCompletedWithWrappedException(h4, ex);
2499 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2500 >    }}
2501  
2502 <    public void testAcceptEither_exceptionalCompletion4() {
2502 >    public void testAcceptEither_exceptionalCompletion2() {
2503          for (ExecutionMode m : ExecutionMode.values())
2504 <        for (Integer v1 : new Integer[] { 1, null }) {
2505 <
2504 >        for (boolean fFirst : new boolean[] { true, false })
2505 >        for (Integer v1 : new Integer[] { 1, null })
2506 >    {
2507          final CompletableFuture<Integer> f = new CompletableFuture<>();
2508          final CompletableFuture<Integer> g = new CompletableFuture<>();
2308        final IncAction r = new IncAction();
2509          final CFException ex = new CFException();
2510 +        final NoopConsumer[] rs = new NoopConsumer[6];
2511 +        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2512  
2513 <        f.completeExceptionally(ex);
2514 <        g.complete(v1);
2515 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2513 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2514 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2515 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2516 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2517 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2518 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2519  
2520 <        // unspecified behavior
2316 <        Integer v;
2520 >        // unspecified behavior - both source completions available
2521          try {
2522 <            assertEquals(h.join(), null);
2523 <            assertEquals(r.invocationCount, 1);
2320 <            assertEquals(inc(v1), r.value);
2522 >            assertEquals(null, h0.join());
2523 >            rs[0].assertValue(v1);
2524          } catch (CompletionException ok) {
2525 <            checkCompletedWithWrappedCFException(h, ex);
2526 <            assertEquals(r.invocationCount, 0);
2525 >            checkCompletedWithWrappedException(h0, ex);
2526 >            rs[0].assertNotInvoked();
2527          }
2528 <
2529 <        checkCompletedWithWrappedCFException(f, ex);
2530 <        checkCompletedNormally(g, v1);
2528 >        try {
2529 >            assertEquals(null, h1.join());
2530 >            rs[1].assertValue(v1);
2531 >        } catch (CompletionException ok) {
2532 >            checkCompletedWithWrappedException(h1, ex);
2533 >            rs[1].assertNotInvoked();
2534          }
2535 <    }
2536 <
2537 <    /**
2538 <     * acceptEither result completes exceptionally if action does
2539 <     */
2540 <    public void testAcceptEither_actionFailed1() {
2541 <        for (ExecutionMode m : ExecutionMode.values())
2542 <        for (Integer v1 : new Integer[] { 1, null })
2543 <        for (Integer v2 : new Integer[] { 2, null }) {
2544 <
2545 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2546 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2547 <        final FailingConsumer r = new FailingConsumer();
2342 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2343 <
2344 <        f.complete(v1);
2345 <        checkCompletedWithWrappedCFException(h);
2346 <        g.complete(v2);
2347 <        checkCompletedNormally(f, v1);
2348 <        checkCompletedNormally(g, v2);
2535 >        try {
2536 >            assertEquals(null, h2.join());
2537 >            rs[2].assertValue(v1);
2538 >        } catch (CompletionException ok) {
2539 >            checkCompletedWithWrappedException(h2, ex);
2540 >            rs[2].assertNotInvoked();
2541 >        }
2542 >        try {
2543 >            assertEquals(null, h3.join());
2544 >            rs[3].assertValue(v1);
2545 >        } catch (CompletionException ok) {
2546 >            checkCompletedWithWrappedException(h3, ex);
2547 >            rs[3].assertNotInvoked();
2548          }
2350    }
2351
2352    public void testAcceptEither_actionFailed2() {
2353        for (ExecutionMode m : ExecutionMode.values())
2354        for (Integer v1 : new Integer[] { 1, null })
2355        for (Integer v2 : new Integer[] { 2, null }) {
2356
2357        final CompletableFuture<Integer> f = new CompletableFuture<>();
2358        final CompletableFuture<Integer> g = new CompletableFuture<>();
2359        final FailingConsumer r = new FailingConsumer();
2360        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2549  
2362        g.complete(v2);
2363        checkCompletedWithWrappedCFException(h);
2364        f.complete(v1);
2550          checkCompletedNormally(f, v1);
2551 <        checkCompletedNormally(g, v2);
2552 <        }
2368 <    }
2551 >        checkCompletedExceptionally(g, ex);
2552 >    }}
2553  
2554      /**
2555       * acceptEither result completes exceptionally if either source cancelled
2556       */
2557 <    public void testAcceptEither_sourceCancelled1() {
2374 <        for (ExecutionMode m : ExecutionMode.values())
2375 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2376 <        for (Integer v1 : new Integer[] { 1, null }) {
2377 <
2378 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2379 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2380 <        final IncAction r = new IncAction();
2381 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2382 <
2383 <        assertTrue(f.cancel(mayInterruptIfRunning));
2384 <        checkCompletedWithWrappedCancellationException(h);
2385 <        g.complete(v1);
2386 <
2387 <        checkCancelled(f);
2388 <        assertEquals(r.invocationCount, 0);
2389 <        checkCompletedNormally(g, v1);
2390 <        checkCompletedWithWrappedCancellationException(h);
2391 <        }
2392 <    }
2393 <
2394 <    public void testAcceptEither_sourceCancelled2() {
2557 >    public void testAcceptEither_sourceCancelled() {
2558          for (ExecutionMode m : ExecutionMode.values())
2559          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2560 <        for (Integer v1 : new Integer[] { 1, null }) {
2561 <
2560 >        for (Integer v1 : new Integer[] { 1, null })
2561 >    {
2562          final CompletableFuture<Integer> f = new CompletableFuture<>();
2563          final CompletableFuture<Integer> g = new CompletableFuture<>();
2564 <        final IncAction r = new IncAction();
2565 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2403 <
2404 <        assertTrue(g.cancel(mayInterruptIfRunning));
2405 <        checkCompletedWithWrappedCancellationException(h);
2406 <        f.complete(v1);
2407 <
2408 <        checkCancelled(g);
2409 <        assertEquals(r.invocationCount, 0);
2410 <        checkCompletedNormally(f, v1);
2411 <        checkCompletedWithWrappedCancellationException(h);
2412 <        }
2413 <    }
2414 <
2415 <    public void testAcceptEither_sourceCancelled3() {
2416 <        for (ExecutionMode m : ExecutionMode.values())
2417 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2418 <        for (Integer v1 : new Integer[] { 1, null }) {
2564 >        final NoopConsumer[] rs = new NoopConsumer[6];
2565 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2566  
2567 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2568 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2569 <        final IncAction r = new IncAction();
2567 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2568 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2569 >        checkIncomplete(h0);
2570 >        checkIncomplete(h1);
2571 >        rs[0].assertNotInvoked();
2572 >        rs[1].assertNotInvoked();
2573 >        f.cancel(mayInterruptIfRunning);
2574 >        checkCompletedWithWrappedCancellationException(h0);
2575 >        checkCompletedWithWrappedCancellationException(h1);
2576 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2577 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2578 >        checkCompletedWithWrappedCancellationException(h2);
2579 >        checkCompletedWithWrappedCancellationException(h3);
2580  
2581 <        assertTrue(g.cancel(mayInterruptIfRunning));
2425 <        f.complete(v1);
2426 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2581 >        g.complete(v1);
2582  
2583 <        // unspecified behavior
2584 <        Integer v;
2583 >        // unspecified behavior - both source completions available
2584 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2585 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2586          try {
2587 <            assertEquals(h.join(), null);
2588 <            assertEquals(r.invocationCount, 1);
2433 <            assertEquals(inc(v1), r.value);
2587 >            assertNull(h4.join());
2588 >            rs[4].assertValue(v1);
2589          } catch (CompletionException ok) {
2590 <            checkCompletedWithWrappedCancellationException(h);
2591 <            assertEquals(r.invocationCount, 0);
2437 <        }
2438 <
2439 <        checkCancelled(g);
2440 <        checkCompletedNormally(f, v1);
2590 >            checkCompletedWithWrappedCancellationException(h4);
2591 >            rs[4].assertNotInvoked();
2592          }
2442    }
2443
2444    public void testAcceptEither_sourceCancelled4() {
2445        for (ExecutionMode m : ExecutionMode.values())
2446        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2447        for (Integer v1 : new Integer[] { 1, null }) {
2448
2449        final CompletableFuture<Integer> f = new CompletableFuture<>();
2450        final CompletableFuture<Integer> g = new CompletableFuture<>();
2451        final IncAction r = new IncAction();
2452
2453        assertTrue(f.cancel(mayInterruptIfRunning));
2454        g.complete(v1);
2455        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2456
2457        // unspecified behavior
2458        Integer v;
2593          try {
2594 <            assertEquals(h.join(), null);
2595 <            assertEquals(r.invocationCount, 1);
2462 <            assertEquals(inc(v1), r.value);
2594 >            assertNull(h5.join());
2595 >            rs[5].assertValue(v1);
2596          } catch (CompletionException ok) {
2597 <            checkCompletedWithWrappedCancellationException(h);
2598 <            assertEquals(r.invocationCount, 0);
2597 >            checkCompletedWithWrappedCancellationException(h5);
2598 >            rs[5].assertNotInvoked();
2599          }
2600  
2601          checkCancelled(f);
2602          checkCompletedNormally(g, v1);
2603 <        }
2604 <    }
2603 >        checkCompletedWithWrappedCancellationException(h0);
2604 >        checkCompletedWithWrappedCancellationException(h1);
2605 >        checkCompletedWithWrappedCancellationException(h2);
2606 >        checkCompletedWithWrappedCancellationException(h3);
2607 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2608 >    }}
2609  
2610      /**
2611 <     * runAfterEither result completes normally after normal completion
2475 <     * of either source
2611 >     * acceptEither result completes exceptionally if action does
2612       */
2613 <    public void testRunAfterEither_normalCompletion1() {
2613 >    public void testAcceptEither_actionFailed() {
2614          for (ExecutionMode m : ExecutionMode.values())
2615          for (Integer v1 : new Integer[] { 1, null })
2616 <        for (Integer v2 : new Integer[] { 2, null }) {
2617 <
2616 >        for (Integer v2 : new Integer[] { 2, null })
2617 >    {
2618          final CompletableFuture<Integer> f = new CompletableFuture<>();
2619          final CompletableFuture<Integer> g = new CompletableFuture<>();
2620 <        final Noop r = new Noop();
2621 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2620 >        final FailingConsumer[] rs = new FailingConsumer[6];
2621 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2622  
2623 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2624 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2625          f.complete(v1);
2626 <        checkCompletedNormally(h, null);
2627 <        assertEquals(r.invocationCount, 1);
2628 <        g.complete(v2);
2629 <
2630 <        checkCompletedNormally(f, v1);
2631 <        checkCompletedNormally(g, v2);
2632 <        checkCompletedNormally(h, null);
2495 <        assertEquals(r.invocationCount, 1);
2496 <        }
2497 <    }
2626 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2627 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2628 >        checkCompletedWithWrappedCFException(h0);
2629 >        checkCompletedWithWrappedCFException(h1);
2630 >        checkCompletedWithWrappedCFException(h2);
2631 >        checkCompletedWithWrappedCFException(h3);
2632 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2633  
2634 <    public void testRunAfterEither_normalCompletion2() {
2500 <        for (ExecutionMode m : ExecutionMode.values())
2501 <        for (Integer v1 : new Integer[] { 1, null })
2502 <        for (Integer v2 : new Integer[] { 2, null }) {
2634 >        g.complete(v2);
2635  
2636 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2637 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2638 <        final Noop r = new Noop();
2507 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2636 >        // unspecified behavior - both source completions available
2637 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2638 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2639  
2640 <        g.complete(v2);
2641 <        checkCompletedNormally(h, null);
2642 <        assertEquals(r.invocationCount, 1);
2643 <        f.complete(v1);
2640 >        checkCompletedWithWrappedCFException(h4);
2641 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2642 >                   Objects.equals(v2, rs[4].value));
2643 >        checkCompletedWithWrappedCFException(h5);
2644 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2645 >                   Objects.equals(v2, rs[5].value));
2646  
2647          checkCompletedNormally(f, v1);
2648          checkCompletedNormally(g, v2);
2649 <        checkCompletedNormally(h, null);
2650 <        assertEquals(r.invocationCount, 1);
2651 <        }
2652 <    }
2653 <    public void testRunAfterEither_normalCompletion3() {
2649 >    }}
2650 >
2651 >    /**
2652 >     * runAfterEither result completes normally after normal completion
2653 >     * of either source
2654 >     */
2655 >    public void testRunAfterEither_normalCompletion() {
2656          for (ExecutionMode m : ExecutionMode.values())
2657          for (Integer v1 : new Integer[] { 1, null })
2658 <        for (Integer v2 : new Integer[] { 2, null }) {
2659 <
2658 >        for (Integer v2 : new Integer[] { 2, null })
2659 >    {
2660          final CompletableFuture<Integer> f = new CompletableFuture<>();
2661          final CompletableFuture<Integer> g = new CompletableFuture<>();
2662 <        final Noop r = new Noop();
2662 >        final Noop[] rs = new Noop[6];
2663 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2664  
2665 +        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2666 +        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2667 +        checkIncomplete(h0);
2668 +        checkIncomplete(h1);
2669 +        rs[0].assertNotInvoked();
2670 +        rs[1].assertNotInvoked();
2671          f.complete(v1);
2672 +        checkCompletedNormally(h0, null);
2673 +        checkCompletedNormally(h1, null);
2674 +        rs[0].assertInvoked();
2675 +        rs[1].assertInvoked();
2676 +        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2677 +        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2678 +        checkCompletedNormally(h2, null);
2679 +        checkCompletedNormally(h3, null);
2680 +        rs[2].assertInvoked();
2681 +        rs[3].assertInvoked();
2682 +
2683          g.complete(v2);
2531        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2684  
2685 <        checkCompletedNormally(h, null);
2685 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2686 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2687 >
2688          checkCompletedNormally(f, v1);
2689          checkCompletedNormally(g, v2);
2690 <        assertEquals(r.invocationCount, 1);
2691 <        }
2692 <    }
2690 >        checkCompletedNormally(h0, null);
2691 >        checkCompletedNormally(h1, null);
2692 >        checkCompletedNormally(h2, null);
2693 >        checkCompletedNormally(h3, null);
2694 >        checkCompletedNormally(h4, null);
2695 >        checkCompletedNormally(h5, null);
2696 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2697 >    }}
2698  
2699      /**
2700       * runAfterEither result completes exceptionally after exceptional
2701       * completion of either source
2702       */
2703 <    public void testRunAfterEither_exceptionalCompletion1() {
2703 >    public void testRunAfterEither_exceptionalCompletion() {
2704          for (ExecutionMode m : ExecutionMode.values())
2705 <        for (Integer v1 : new Integer[] { 1, null }) {
2706 <
2705 >        for (Integer v1 : new Integer[] { 1, null })
2706 >    {
2707          final CompletableFuture<Integer> f = new CompletableFuture<>();
2708          final CompletableFuture<Integer> g = new CompletableFuture<>();
2550        final Noop r = new Noop();
2551        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2709          final CFException ex = new CFException();
2710 +        final Noop[] rs = new Noop[6];
2711 +        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2712  
2713 <        f.completeExceptionally(ex);
2714 <        checkCompletedWithWrappedCFException(h, ex);
2715 <        g.complete(v1);
2716 <
2717 <        assertEquals(r.invocationCount, 0);
2718 <        checkCompletedNormally(g, v1);
2719 <        checkCompletedWithWrappedCFException(f, ex);
2720 <        checkCompletedWithWrappedCFException(h, ex);
2721 <        }
2722 <    }
2713 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2714 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2715 >        checkIncomplete(h0);
2716 >        checkIncomplete(h1);
2717 >        rs[0].assertNotInvoked();
2718 >        rs[1].assertNotInvoked();
2719 >        assertTrue(f.completeExceptionally(ex));
2720 >        checkCompletedWithWrappedException(h0, ex);
2721 >        checkCompletedWithWrappedException(h1, ex);
2722 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2723 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2724 >        checkCompletedWithWrappedException(h2, ex);
2725 >        checkCompletedWithWrappedException(h3, ex);
2726  
2727 <    public void testRunAfterEither_exceptionalCompletion2() {
2566 <        for (ExecutionMode m : ExecutionMode.values())
2567 <        for (Integer v1 : new Integer[] { 1, null }) {
2727 >        assertTrue(g.complete(v1));
2728  
2729 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2730 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2731 <        final Noop r = new Noop();
2732 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2733 <        final CFException ex = new CFException();
2734 <
2735 <        g.completeExceptionally(ex);
2736 <        checkCompletedWithWrappedCFException(h, ex);
2737 <        f.complete(v1);
2578 <
2579 <        assertEquals(r.invocationCount, 0);
2580 <        checkCompletedNormally(f, v1);
2581 <        checkCompletedWithWrappedCFException(g, ex);
2582 <        checkCompletedWithWrappedCFException(h, ex);
2729 >        // unspecified behavior - both source completions available
2730 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2731 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2732 >        try {
2733 >            assertNull(h4.join());
2734 >            rs[4].assertInvoked();
2735 >        } catch (CompletionException ok) {
2736 >            checkCompletedWithWrappedException(h4, ex);
2737 >            rs[4].assertNotInvoked();
2738          }
2584    }
2585
2586    public void testRunAfterEither_exceptionalCompletion3() {
2587        for (ExecutionMode m : ExecutionMode.values())
2588        for (Integer v1 : new Integer[] { 1, null }) {
2589
2590        final CompletableFuture<Integer> f = new CompletableFuture<>();
2591        final CompletableFuture<Integer> g = new CompletableFuture<>();
2592        final Noop r = new Noop();
2593        final CFException ex = new CFException();
2594
2595        g.completeExceptionally(ex);
2596        f.complete(v1);
2597        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2598
2599        // unspecified behavior
2600        Integer v;
2739          try {
2740 <            assertEquals(h.join(), null);
2741 <            assertEquals(r.invocationCount, 1);
2740 >            assertNull(h5.join());
2741 >            rs[5].assertInvoked();
2742          } catch (CompletionException ok) {
2743 <            checkCompletedWithWrappedCFException(h, ex);
2744 <            assertEquals(r.invocationCount, 0);
2743 >            checkCompletedWithWrappedException(h5, ex);
2744 >            rs[5].assertNotInvoked();
2745          }
2746  
2747 <        checkCompletedWithWrappedCFException(g, ex);
2748 <        checkCompletedNormally(f, v1);
2749 <        }
2750 <    }
2747 >        checkCompletedExceptionally(f, ex);
2748 >        checkCompletedNormally(g, v1);
2749 >        checkCompletedWithWrappedException(h0, ex);
2750 >        checkCompletedWithWrappedException(h1, ex);
2751 >        checkCompletedWithWrappedException(h2, ex);
2752 >        checkCompletedWithWrappedException(h3, ex);
2753 >        checkCompletedWithWrappedException(h4, ex);
2754 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2755 >    }}
2756  
2757 <    public void testRunAfterEither_exceptionalCompletion4() {
2757 >    public void testRunAfterEither_exceptionalCompletion2() {
2758          for (ExecutionMode m : ExecutionMode.values())
2759 <        for (Integer v1 : new Integer[] { 1, null }) {
2760 <
2759 >        for (boolean fFirst : new boolean[] { true, false })
2760 >        for (Integer v1 : new Integer[] { 1, null })
2761 >    {
2762          final CompletableFuture<Integer> f = new CompletableFuture<>();
2763          final CompletableFuture<Integer> g = new CompletableFuture<>();
2620        final Noop r = new Noop();
2764          final CFException ex = new CFException();
2765 +        final Noop[] rs = new Noop[6];
2766 +        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2767  
2768 <        f.completeExceptionally(ex);
2769 <        g.complete(v1);
2770 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2768 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2769 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2770 >        assertTrue( fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2771 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2772 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2773 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2774  
2775 <        // unspecified behavior
2628 <        Integer v;
2775 >        // unspecified behavior - both source completions available
2776          try {
2777 <            assertEquals(h.join(), null);
2778 <            assertEquals(r.invocationCount, 1);
2777 >            assertEquals(null, h0.join());
2778 >            rs[0].assertInvoked();
2779          } catch (CompletionException ok) {
2780 <            checkCompletedWithWrappedCFException(h, ex);
2781 <            assertEquals(r.invocationCount, 0);
2780 >            checkCompletedWithWrappedException(h0, ex);
2781 >            rs[0].assertNotInvoked();
2782          }
2783 <
2784 <        checkCompletedWithWrappedCFException(f, ex);
2785 <        checkCompletedNormally(g, v1);
2783 >        try {
2784 >            assertEquals(null, h1.join());
2785 >            rs[1].assertInvoked();
2786 >        } catch (CompletionException ok) {
2787 >            checkCompletedWithWrappedException(h1, ex);
2788 >            rs[1].assertNotInvoked();
2789          }
2790 <    }
2791 <
2792 <    /**
2793 <     * runAfterEither result completes exceptionally if action does
2794 <     */
2795 <    public void testRunAfterEither_actionFailed1() {
2796 <        for (ExecutionMode m : ExecutionMode.values())
2797 <        for (Integer v1 : new Integer[] { 1, null })
2798 <        for (Integer v2 : new Integer[] { 2, null }) {
2799 <
2800 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2801 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2802 <        final FailingNoop r = new FailingNoop();
2653 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2654 <
2655 <        f.complete(v1);
2656 <        checkCompletedWithWrappedCFException(h);
2657 <        g.complete(v2);
2658 <        checkCompletedNormally(f, v1);
2659 <        checkCompletedNormally(g, v2);
2790 >        try {
2791 >            assertEquals(null, h2.join());
2792 >            rs[2].assertInvoked();
2793 >        } catch (CompletionException ok) {
2794 >            checkCompletedWithWrappedException(h2, ex);
2795 >            rs[2].assertNotInvoked();
2796 >        }
2797 >        try {
2798 >            assertEquals(null, h3.join());
2799 >            rs[3].assertInvoked();
2800 >        } catch (CompletionException ok) {
2801 >            checkCompletedWithWrappedException(h3, ex);
2802 >            rs[3].assertNotInvoked();
2803          }
2661    }
2662
2663    public void testRunAfterEither_actionFailed2() {
2664        for (ExecutionMode m : ExecutionMode.values())
2665        for (Integer v1 : new Integer[] { 1, null })
2666        for (Integer v2 : new Integer[] { 2, null }) {
2667
2668        final CompletableFuture<Integer> f = new CompletableFuture<>();
2669        final CompletableFuture<Integer> g = new CompletableFuture<>();
2670        final FailingNoop r = new FailingNoop();
2671        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2804  
2673        g.complete(v2);
2674        checkCompletedWithWrappedCFException(h);
2675        f.complete(v1);
2805          checkCompletedNormally(f, v1);
2806 <        checkCompletedNormally(g, v2);
2807 <        }
2679 <    }
2806 >        checkCompletedExceptionally(g, ex);
2807 >    }}
2808  
2809      /**
2810       * runAfterEither result completes exceptionally if either source cancelled
2811       */
2812 <    public void testRunAfterEither_sourceCancelled1() {
2812 >    public void testRunAfterEither_sourceCancelled() {
2813          for (ExecutionMode m : ExecutionMode.values())
2814          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2815 <        for (Integer v1 : new Integer[] { 1, null }) {
2816 <
2815 >        for (Integer v1 : new Integer[] { 1, null })
2816 >    {
2817          final CompletableFuture<Integer> f = new CompletableFuture<>();
2818          final CompletableFuture<Integer> g = new CompletableFuture<>();
2819 <        final Noop r = new Noop();
2820 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2693 <
2694 <        assertTrue(f.cancel(mayInterruptIfRunning));
2695 <        checkCompletedWithWrappedCancellationException(h);
2696 <        g.complete(v1);
2697 <
2698 <        checkCancelled(f);
2699 <        assertEquals(r.invocationCount, 0);
2700 <        checkCompletedNormally(g, v1);
2701 <        checkCompletedWithWrappedCancellationException(h);
2702 <        }
2703 <    }
2819 >        final Noop[] rs = new Noop[6];
2820 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2821  
2822 <    public void testRunAfterEither_sourceCancelled2() {
2823 <        for (ExecutionMode m : ExecutionMode.values())
2824 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2825 <        for (Integer v1 : new Integer[] { 1, null }) {
2826 <
2827 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2828 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2829 <        final Noop r = new Noop();
2830 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2822 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2823 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2824 >        checkIncomplete(h0);
2825 >        checkIncomplete(h1);
2826 >        rs[0].assertNotInvoked();
2827 >        rs[1].assertNotInvoked();
2828 >        f.cancel(mayInterruptIfRunning);
2829 >        checkCompletedWithWrappedCancellationException(h0);
2830 >        checkCompletedWithWrappedCancellationException(h1);
2831 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2832 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2833 >        checkCompletedWithWrappedCancellationException(h2);
2834 >        checkCompletedWithWrappedCancellationException(h3);
2835  
2836 <        assertTrue(g.cancel(mayInterruptIfRunning));
2716 <        checkCompletedWithWrappedCancellationException(h);
2717 <        f.complete(v1);
2836 >        assertTrue(g.complete(v1));
2837  
2838 <        checkCancelled(g);
2839 <        assertEquals(r.invocationCount, 0);
2840 <        checkCompletedNormally(f, v1);
2841 <        checkCompletedWithWrappedCancellationException(h);
2838 >        // unspecified behavior - both source completions available
2839 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2840 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2841 >        try {
2842 >            assertNull(h4.join());
2843 >            rs[4].assertInvoked();
2844 >        } catch (CompletionException ok) {
2845 >            checkCompletedWithWrappedCancellationException(h4);
2846 >            rs[4].assertNotInvoked();
2847          }
2724    }
2725
2726    public void testRunAfterEither_sourceCancelled3() {
2727        for (ExecutionMode m : ExecutionMode.values())
2728        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2729        for (Integer v1 : new Integer[] { 1, null }) {
2730
2731        final CompletableFuture<Integer> f = new CompletableFuture<>();
2732        final CompletableFuture<Integer> g = new CompletableFuture<>();
2733        final Noop r = new Noop();
2734
2735        assertTrue(g.cancel(mayInterruptIfRunning));
2736        f.complete(v1);
2737        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2738
2739        // unspecified behavior
2740        Integer v;
2848          try {
2849 <            assertEquals(h.join(), null);
2850 <            assertEquals(r.invocationCount, 1);
2849 >            assertNull(h5.join());
2850 >            rs[5].assertInvoked();
2851          } catch (CompletionException ok) {
2852 <            checkCompletedWithWrappedCancellationException(h);
2853 <            assertEquals(r.invocationCount, 0);
2852 >            checkCompletedWithWrappedCancellationException(h5);
2853 >            rs[5].assertNotInvoked();
2854          }
2855  
2856 <        checkCancelled(g);
2857 <        checkCompletedNormally(f, v1);
2858 <        }
2859 <    }
2856 >        checkCancelled(f);
2857 >        checkCompletedNormally(g, v1);
2858 >        checkCompletedWithWrappedCancellationException(h0);
2859 >        checkCompletedWithWrappedCancellationException(h1);
2860 >        checkCompletedWithWrappedCancellationException(h2);
2861 >        checkCompletedWithWrappedCancellationException(h3);
2862 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2863 >    }}
2864  
2865 <    public void testRunAfterEither_sourceCancelled4() {
2865 >    /**
2866 >     * runAfterEither result completes exceptionally if action does
2867 >     */
2868 >    public void testRunAfterEither_actionFailed() {
2869          for (ExecutionMode m : ExecutionMode.values())
2870 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2871 <        for (Integer v1 : new Integer[] { 1, null }) {
2872 <
2870 >        for (Integer v1 : new Integer[] { 1, null })
2871 >        for (Integer v2 : new Integer[] { 2, null })
2872 >    {
2873          final CompletableFuture<Integer> f = new CompletableFuture<>();
2874          final CompletableFuture<Integer> g = new CompletableFuture<>();
2875 <        final Noop r = new Noop();
2875 >        final FailingRunnable[] rs = new FailingRunnable[6];
2876 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2877  
2878 <        assertTrue(f.cancel(mayInterruptIfRunning));
2879 <        g.complete(v1);
2880 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2878 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2879 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2880 >        assertTrue(f.complete(v1));
2881 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2882 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2883 >        checkCompletedWithWrappedCFException(h0);
2884 >        checkCompletedWithWrappedCFException(h1);
2885 >        checkCompletedWithWrappedCFException(h2);
2886 >        checkCompletedWithWrappedCFException(h3);
2887 >        for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2888 >        assertTrue(g.complete(v2));
2889 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2890 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2891 >        checkCompletedWithWrappedCFException(h4);
2892 >        checkCompletedWithWrappedCFException(h5);
2893  
2894 <        // unspecified behavior
2895 <        Integer v;
2896 <        try {
2897 <            assertEquals(h.join(), null);
2771 <            assertEquals(r.invocationCount, 1);
2772 <        } catch (CompletionException ok) {
2773 <            checkCompletedWithWrappedCancellationException(h);
2774 <            assertEquals(r.invocationCount, 0);
2775 <        }
2776 <
2777 <        checkCancelled(f);
2778 <        checkCompletedNormally(g, v1);
2779 <        }
2780 <    }
2894 >        checkCompletedNormally(f, v1);
2895 >        checkCompletedNormally(g, v2);
2896 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2897 >    }}
2898  
2899      /**
2900       * thenCompose result completes normally after normal completion of source
2901       */
2902 <    public void testThenCompose() {
2903 <        CompletableFuture<Integer> f, g;
2904 <        CompletableFutureInc r;
2905 <
2906 <        f = new CompletableFuture<>();
2907 <        g = f.thenCompose(r = new CompletableFutureInc());
2908 <        f.complete(one);
2909 <        checkCompletedNormally(g, two);
2910 <        assertTrue(r.ran);
2902 >    public void testThenCompose_normalCompletion() {
2903 >        for (ExecutionMode m : ExecutionMode.values())
2904 >        for (boolean createIncomplete : new boolean[] { true, false })
2905 >        for (Integer v1 : new Integer[] { 1, null })
2906 >    {
2907 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2908 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2909 >        if (!createIncomplete) assertTrue(f.complete(v1));
2910 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2911 >        if (createIncomplete) assertTrue(f.complete(v1));
2912  
2913 <        f = new CompletableFuture<>();
2914 <        f.complete(one);
2915 <        g = f.thenCompose(r = new CompletableFutureInc());
2916 <        checkCompletedNormally(g, two);
2799 <        assertTrue(r.ran);
2800 <    }
2913 >        checkCompletedNormally(g, inc(v1));
2914 >        checkCompletedNormally(f, v1);
2915 >        r.assertValue(v1);
2916 >    }}
2917  
2918      /**
2919       * thenCompose result completes exceptionally after exceptional
2920       * completion of source
2921       */
2922 <    public void testThenCompose2() {
2923 <        CompletableFuture<Integer> f, g;
2924 <        CompletableFutureInc r;
2925 <
2926 <        f = new CompletableFuture<>();
2927 <        g = f.thenCompose(r = new CompletableFutureInc());
2928 <        f.completeExceptionally(new CFException());
2929 <        checkCompletedWithWrappedCFException(g);
2922 >    public void testThenCompose_exceptionalCompletion() {
2923 >        for (ExecutionMode m : ExecutionMode.values())
2924 >        for (boolean createIncomplete : new boolean[] { true, false })
2925 >    {
2926 >        final CFException ex = new CFException();
2927 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2928 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2929 >        if (!createIncomplete) f.completeExceptionally(ex);
2930 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2931 >        if (createIncomplete) f.completeExceptionally(ex);
2932  
2933 <        f = new CompletableFuture<>();
2934 <        f.completeExceptionally(new CFException());
2935 <        g = f.thenCompose(r = new CompletableFutureInc());
2936 <        checkCompletedWithWrappedCFException(g);
2819 <    }
2933 >        checkCompletedWithWrappedException(g, ex);
2934 >        checkCompletedExceptionally(f, ex);
2935 >        r.assertNotInvoked();
2936 >    }}
2937  
2938      /**
2939       * thenCompose result completes exceptionally if action does
2940       */
2941 <    public void testThenCompose3() {
2942 <        CompletableFuture<Integer> f, g;
2943 <        FailingCompletableFutureFunction r;
2944 <
2945 <        f = new CompletableFuture<>();
2946 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2947 <        f.complete(one);
2948 <        checkCompletedWithWrappedCFException(g);
2941 >    public void testThenCompose_actionFailed() {
2942 >        for (ExecutionMode m : ExecutionMode.values())
2943 >        for (boolean createIncomplete : new boolean[] { true, false })
2944 >        for (Integer v1 : new Integer[] { 1, null })
2945 >    {
2946 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2947 >        final FailingCompletableFutureFunction r
2948 >            = new FailingCompletableFutureFunction(m);
2949 >        if (!createIncomplete) assertTrue(f.complete(v1));
2950 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2951 >        if (createIncomplete) assertTrue(f.complete(v1));
2952  
2833        f = new CompletableFuture<>();
2834        f.complete(one);
2835        g = f.thenCompose(r = new FailingCompletableFutureFunction());
2953          checkCompletedWithWrappedCFException(g);
2954 <    }
2954 >        checkCompletedNormally(f, v1);
2955 >    }}
2956  
2957      /**
2958       * thenCompose result completes exceptionally if source cancelled
2959       */
2960 <    public void testThenCompose4() {
2961 <        CompletableFuture<Integer> f, g;
2962 <        CompletableFutureInc r;
2963 <
2964 <        f = new CompletableFuture<>();
2965 <        g = f.thenCompose(r = new CompletableFutureInc());
2966 <        assertTrue(f.cancel(true));
2967 <        checkCompletedWithWrappedCancellationException(g);
2968 <
2969 <        f = new CompletableFuture<>();
2970 <        assertTrue(f.cancel(true));
2971 <        g = f.thenCompose(r = new CompletableFutureInc());
2972 <        checkCompletedWithWrappedCancellationException(g);
2855 <    }
2856 <
2857 <    // asyncs
2858 <
2859 <    /**
2860 <     * thenRunAsync result completes normally after normal completion of source
2861 <     */
2862 <    public void testThenRunAsync() {
2863 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2864 <        Noop r = new Noop();
2865 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2866 <        f.complete(null);
2867 <        checkCompletedNormally(g, null);
2868 <
2869 <        // reordered version
2870 <        f = new CompletableFuture<>();
2871 <        f.complete(null);
2872 <        r = new Noop();
2873 <        g = f.thenRunAsync(r);
2874 <        checkCompletedNormally(g, null);
2875 <    }
2876 <
2877 <    /**
2878 <     * thenRunAsync result completes exceptionally after exceptional
2879 <     * completion of source
2880 <     */
2881 <    public void testThenRunAsync2() {
2882 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2883 <        Noop r = new Noop();
2884 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2885 <        f.completeExceptionally(new CFException());
2886 <        try {
2887 <            g.join();
2888 <            shouldThrow();
2889 <        } catch (CompletionException success) {}
2890 <        checkCompletedWithWrappedCFException(g);
2891 <    }
2892 <
2893 <    /**
2894 <     * thenRunAsync result completes exceptionally if action does
2895 <     */
2896 <    public void testThenRunAsync3() {
2897 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2898 <        FailingNoop r = new FailingNoop();
2899 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2900 <        f.complete(null);
2901 <        checkCompletedWithWrappedCFException(g);
2902 <    }
2903 <
2904 <    /**
2905 <     * thenRunAsync result completes exceptionally if source cancelled
2906 <     */
2907 <    public void testThenRunAsync4() {
2908 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2909 <        Noop r = new Noop();
2910 <        CompletableFuture<Void> g = f.thenRunAsync(r);
2911 <        assertTrue(f.cancel(true));
2912 <        checkCompletedWithWrappedCancellationException(g);
2913 <    }
2914 <
2915 <    /**
2916 <     * thenApplyAsync result completes normally after normal completion of source
2917 <     */
2918 <    public void testThenApplyAsync() {
2919 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2920 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2921 <        f.complete(one);
2922 <        checkCompletedNormally(g, two);
2923 <    }
2924 <
2925 <    /**
2926 <     * thenApplyAsync result completes exceptionally after exceptional
2927 <     * completion of source
2928 <     */
2929 <    public void testThenApplyAsync2() {
2930 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2931 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2932 <        f.completeExceptionally(new CFException());
2933 <        checkCompletedWithWrappedCFException(g);
2934 <    }
2935 <
2936 <    /**
2937 <     * thenApplyAsync result completes exceptionally if action does
2938 <     */
2939 <    public void testThenApplyAsync3() {
2940 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2941 <        FailingFunction r = new FailingFunction();
2942 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2943 <        f.complete(null);
2944 <        checkCompletedWithWrappedCFException(g);
2945 <    }
2946 <
2947 <    /**
2948 <     * thenApplyAsync result completes exceptionally if source cancelled
2949 <     */
2950 <    public void testThenApplyAsync4() {
2951 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2952 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2953 <        assertTrue(f.cancel(true));
2954 <        checkCompletedWithWrappedCancellationException(g);
2955 <    }
2956 <
2957 <    /**
2958 <     * thenAcceptAsync result completes normally after normal
2959 <     * completion of source
2960 <     */
2961 <    public void testThenAcceptAsync() {
2962 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2963 <        IncAction r = new IncAction();
2964 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2965 <        f.complete(one);
2966 <        checkCompletedNormally(g, null);
2967 <        assertEquals(r.value, (Integer) 2);
2968 <    }
2969 <
2970 <    /**
2971 <     * thenAcceptAsync result completes exceptionally after exceptional
2972 <     * completion of source
2973 <     */
2974 <    public void testThenAcceptAsync2() {
2975 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2976 <        IncAction r = new IncAction();
2977 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2978 <        f.completeExceptionally(new CFException());
2979 <        checkCompletedWithWrappedCFException(g);
2980 <    }
2981 <
2982 <    /**
2983 <     * thenAcceptAsync result completes exceptionally if action does
2984 <     */
2985 <    public void testThenAcceptAsync3() {
2986 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2987 <        FailingConsumer r = new FailingConsumer();
2988 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2989 <        f.complete(null);
2990 <        checkCompletedWithWrappedCFException(g);
2991 <    }
2992 <
2993 <    /**
2994 <     * thenAcceptAsync result completes exceptionally if source cancelled
2995 <     */
2996 <    public void testThenAcceptAsync4() {
2997 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2998 <        IncAction r = new IncAction();
2999 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3000 <        assertTrue(f.cancel(true));
3001 <        checkCompletedWithWrappedCancellationException(g);
3002 <    }
3003 <
3004 <    /**
3005 <     * thenComposeAsync result completes normally after normal
3006 <     * completion of source
3007 <     */
3008 <    public void testThenComposeAsync() {
3009 <        CompletableFuture<Integer> f, g;
3010 <        CompletableFutureInc r;
3011 <
3012 <        f = new CompletableFuture<>();
3013 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3014 <        f.complete(one);
3015 <        checkCompletedNormally(g, two);
3016 <
3017 <        f = new CompletableFuture<>();
3018 <        f.complete(one);
3019 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3020 <        checkCompletedNormally(g, two);
3021 <    }
3022 <
3023 <    /**
3024 <     * thenComposeAsync result completes exceptionally after
3025 <     * exceptional completion of source
3026 <     */
3027 <    public void testThenComposeAsync2() {
3028 <        CompletableFuture<Integer> f, g;
3029 <        CompletableFutureInc r;
3030 <
3031 <        f = new CompletableFuture<>();
3032 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3033 <        f.completeExceptionally(new CFException());
3034 <        checkCompletedWithWrappedCFException(g);
3035 <        assertFalse(r.ran);
3036 <
3037 <        f = new CompletableFuture<>();
3038 <        f.completeExceptionally(new CFException());
3039 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3040 <        checkCompletedWithWrappedCFException(g);
3041 <        assertFalse(r.ran);
3042 <    }
3043 <
3044 <    /**
3045 <     * thenComposeAsync result completes exceptionally if action does
3046 <     */
3047 <    public void testThenComposeAsync3() {
3048 <        CompletableFuture<Integer> f, g;
3049 <        FailingCompletableFutureFunction r;
3050 <
3051 <        f = new CompletableFuture<>();
3052 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3053 <        f.complete(one);
3054 <        checkCompletedWithWrappedCFException(g);
3055 <
3056 <        f = new CompletableFuture<>();
3057 <        f.complete(one);
3058 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3059 <        checkCompletedWithWrappedCFException(g);
3060 <    }
3061 <
3062 <    /**
3063 <     * thenComposeAsync result completes exceptionally if source cancelled
3064 <     */
3065 <    public void testThenComposeAsync4() {
3066 <        CompletableFuture<Integer> f, g;
3067 <        CompletableFutureInc r;
3068 <
3069 <        f = new CompletableFuture<>();
3070 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3071 <        assertTrue(f.cancel(true));
3072 <        checkCompletedWithWrappedCancellationException(g);
3073 <
3074 <        f = new CompletableFuture<>();
3075 <        assertTrue(f.cancel(true));
3076 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
3077 <        checkCompletedWithWrappedCancellationException(g);
3078 <    }
3079 <
3080 <    // async with explicit executors
3081 <
3082 <    /**
3083 <     * thenRunAsync result completes normally after normal completion of source
3084 <     */
3085 <    public void testThenRunAsyncE() {
3086 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3087 <        Noop r = new Noop();
3088 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3089 <        f.complete(null);
3090 <        checkCompletedNormally(g, null);
3091 <
3092 <        // reordered version
3093 <        f = new CompletableFuture<>();
3094 <        f.complete(null);
3095 <        r = new Noop();
3096 <        g = f.thenRunAsync(r, new ThreadExecutor());
3097 <        checkCompletedNormally(g, null);
3098 <    }
3099 <
3100 <    /**
3101 <     * thenRunAsync result completes exceptionally after exceptional
3102 <     * completion of source
3103 <     */
3104 <    public void testThenRunAsync2E() {
3105 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3106 <        Noop r = new Noop();
3107 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3108 <        f.completeExceptionally(new CFException());
3109 <        try {
3110 <            g.join();
3111 <            shouldThrow();
3112 <        } catch (CompletionException success) {}
3113 <        checkCompletedWithWrappedCFException(g);
3114 <    }
3115 <
3116 <    /**
3117 <     * thenRunAsync result completes exceptionally if action does
3118 <     */
3119 <    public void testThenRunAsync3E() {
3120 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3121 <        FailingNoop r = new FailingNoop();
3122 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3123 <        f.complete(null);
3124 <        checkCompletedWithWrappedCFException(g);
3125 <    }
3126 <
3127 <    /**
3128 <     * thenRunAsync result completes exceptionally if source cancelled
3129 <     */
3130 <    public void testThenRunAsync4E() {
3131 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3132 <        Noop r = new Noop();
3133 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3134 <        assertTrue(f.cancel(true));
3135 <        checkCompletedWithWrappedCancellationException(g);
3136 <    }
3137 <
3138 <    /**
3139 <     * thenApplyAsync result completes normally after normal completion of source
3140 <     */
3141 <    public void testThenApplyAsyncE() {
3142 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3143 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3144 <        f.complete(one);
3145 <        checkCompletedNormally(g, two);
3146 <    }
3147 <
3148 <    /**
3149 <     * thenApplyAsync result completes exceptionally after exceptional
3150 <     * completion of source
3151 <     */
3152 <    public void testThenApplyAsync2E() {
3153 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3154 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3155 <        f.completeExceptionally(new CFException());
3156 <        checkCompletedWithWrappedCFException(g);
3157 <    }
3158 <
3159 <    /**
3160 <     * thenApplyAsync result completes exceptionally if action does
3161 <     */
3162 <    public void testThenApplyAsync3E() {
3163 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3164 <        FailingFunction r = new FailingFunction();
3165 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3166 <        f.complete(null);
3167 <        checkCompletedWithWrappedCFException(g);
3168 <    }
3169 <
3170 <    /**
3171 <     * thenApplyAsync result completes exceptionally if source cancelled
3172 <     */
3173 <    public void testThenApplyAsync4E() {
3174 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3175 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3176 <        assertTrue(f.cancel(true));
3177 <        checkCompletedWithWrappedCancellationException(g);
3178 <    }
3179 <
3180 <    /**
3181 <     * thenAcceptAsync result completes normally after normal
3182 <     * completion of source
3183 <     */
3184 <    public void testThenAcceptAsyncE() {
3185 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3186 <        IncAction r = new IncAction();
3187 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3188 <        f.complete(one);
3189 <        checkCompletedNormally(g, null);
3190 <        assertEquals(r.value, (Integer) 2);
3191 <    }
3192 <
3193 <    /**
3194 <     * thenAcceptAsync result completes exceptionally after exceptional
3195 <     * completion of source
3196 <     */
3197 <    public void testThenAcceptAsync2E() {
3198 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3199 <        IncAction r = new IncAction();
3200 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3201 <        f.completeExceptionally(new CFException());
3202 <        checkCompletedWithWrappedCFException(g);
3203 <    }
3204 <
3205 <    /**
3206 <     * thenAcceptAsync result completes exceptionally if action does
3207 <     */
3208 <    public void testThenAcceptAsync3E() {
3209 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3210 <        FailingConsumer r = new FailingConsumer();
3211 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3212 <        f.complete(null);
3213 <        checkCompletedWithWrappedCFException(g);
3214 <    }
3215 <
3216 <    /**
3217 <     * thenAcceptAsync result completes exceptionally if source cancelled
3218 <     */
3219 <    public void testThenAcceptAsync4E() {
3220 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3221 <        IncAction r = new IncAction();
3222 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3223 <        assertTrue(f.cancel(true));
3224 <        checkCompletedWithWrappedCancellationException(g);
3225 <    }
3226 <
3227 <    /**
3228 <     * thenComposeAsync result completes normally after normal
3229 <     * completion of source
3230 <     */
3231 <    public void testThenComposeAsyncE() {
3232 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3233 <        CompletableFutureInc r = new CompletableFutureInc();
3234 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3235 <        f.complete(one);
3236 <        checkCompletedNormally(g, two);
3237 <    }
3238 <
3239 <    /**
3240 <     * thenComposeAsync result completes exceptionally after
3241 <     * exceptional completion of source
3242 <     */
3243 <    public void testThenComposeAsync2E() {
3244 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3245 <        CompletableFutureInc r = new CompletableFutureInc();
3246 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3247 <        f.completeExceptionally(new CFException());
3248 <        checkCompletedWithWrappedCFException(g);
3249 <    }
3250 <
3251 <    /**
3252 <     * thenComposeAsync result completes exceptionally if action does
3253 <     */
3254 <    public void testThenComposeAsync3E() {
3255 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3256 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
3257 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3258 <        f.complete(one);
3259 <        checkCompletedWithWrappedCFException(g);
3260 <    }
2960 >    public void testThenCompose_sourceCancelled() {
2961 >        for (ExecutionMode m : ExecutionMode.values())
2962 >        for (boolean createIncomplete : new boolean[] { true, false })
2963 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2964 >    {
2965 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2966 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2967 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2968 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2969 >        if (createIncomplete) {
2970 >            checkIncomplete(g);
2971 >            assertTrue(f.cancel(mayInterruptIfRunning));
2972 >        }
2973  
3262    /**
3263     * thenComposeAsync result completes exceptionally if source cancelled
3264     */
3265    public void testThenComposeAsync4E() {
3266        CompletableFuture<Integer> f = new CompletableFuture<>();
3267        CompletableFutureInc r = new CompletableFutureInc();
3268        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3269        assertTrue(f.cancel(true));
2974          checkCompletedWithWrappedCancellationException(g);
2975 <    }
2975 >        checkCancelled(f);
2976 >    }}
2977  
2978      // other static methods
2979  
# Line 3286 | Line 2991 | public class CompletableFutureTest exten
2991       * when all components complete normally
2992       */
2993      public void testAllOf_normal() throws Exception {
2994 <        for (int k = 1; k < 20; ++k) {
2995 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2996 <            for (int i = 0; i < k; ++i)
2994 >        for (int k = 1; k < 10; k++) {
2995 >            CompletableFuture<Integer>[] fs
2996 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2997 >            for (int i = 0; i < k; i++)
2998                  fs[i] = new CompletableFuture<>();
2999              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3000 <            for (int i = 0; i < k; ++i) {
3000 >            for (int i = 0; i < k; i++) {
3001                  checkIncomplete(f);
3002                  checkIncomplete(CompletableFuture.allOf(fs));
3003                  fs[i].complete(one);
# Line 3301 | Line 3007 | public class CompletableFutureTest exten
3007          }
3008      }
3009  
3010 +    public void testAllOf_backwards() throws Exception {
3011 +        for (int k = 1; k < 10; k++) {
3012 +            CompletableFuture<Integer>[] fs
3013 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3014 +            for (int i = 0; i < k; i++)
3015 +                fs[i] = new CompletableFuture<>();
3016 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3017 +            for (int i = k - 1; i >= 0; i--) {
3018 +                checkIncomplete(f);
3019 +                checkIncomplete(CompletableFuture.allOf(fs));
3020 +                fs[i].complete(one);
3021 +            }
3022 +            checkCompletedNormally(f, null);
3023 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
3024 +        }
3025 +    }
3026 +
3027 +    public void testAllOf_exceptional() throws Exception {
3028 +        for (int k = 1; k < 10; k++) {
3029 +            CompletableFuture<Integer>[] fs
3030 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3031 +            CFException ex = new CFException();
3032 +            for (int i = 0; i < k; i++)
3033 +                fs[i] = new CompletableFuture<>();
3034 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3035 +            for (int i = 0; i < k; i++) {
3036 +                checkIncomplete(f);
3037 +                checkIncomplete(CompletableFuture.allOf(fs));
3038 +                if (i != k/2) {
3039 +                    fs[i].complete(i);
3040 +                    checkCompletedNormally(fs[i], i);
3041 +                } else {
3042 +                    fs[i].completeExceptionally(ex);
3043 +                    checkCompletedExceptionally(fs[i], ex);
3044 +                }
3045 +            }
3046 +            checkCompletedWithWrappedException(f, ex);
3047 +            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3048 +        }
3049 +    }
3050 +
3051      /**
3052       * anyOf(no component futures) returns an incomplete future
3053       */
3054      public void testAnyOf_empty() throws Exception {
3055 +        for (Integer v1 : new Integer[] { 1, null })
3056 +    {
3057          CompletableFuture<Object> f = CompletableFuture.anyOf();
3058          checkIncomplete(f);
3059 <    }
3059 >
3060 >        f.complete(v1);
3061 >        checkCompletedNormally(f, v1);
3062 >    }}
3063  
3064      /**
3065       * anyOf returns a future completed normally with a value when
3066       * a component future does
3067       */
3068      public void testAnyOf_normal() throws Exception {
3069 <        for (int k = 0; k < 10; ++k) {
3069 >        for (int k = 0; k < 10; k++) {
3070              CompletableFuture[] fs = new CompletableFuture[k];
3071 <            for (int i = 0; i < k; ++i)
3071 >            for (int i = 0; i < k; i++)
3072                  fs[i] = new CompletableFuture<>();
3073              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3074              checkIncomplete(f);
3075 <            for (int i = 0; i < k; ++i) {
3076 <                fs[i].complete(one);
3077 <                checkCompletedNormally(f, one);
3078 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3075 >            for (int i = 0; i < k; i++) {
3076 >                fs[i].complete(i);
3077 >                checkCompletedNormally(f, 0);
3078 >                int x = (int) CompletableFuture.anyOf(fs).join();
3079 >                assertTrue(0 <= x && x <= i);
3080 >            }
3081 >        }
3082 >    }
3083 >    public void testAnyOf_normal_backwards() throws Exception {
3084 >        for (int k = 0; k < 10; k++) {
3085 >            CompletableFuture[] fs = new CompletableFuture[k];
3086 >            for (int i = 0; i < k; i++)
3087 >                fs[i] = new CompletableFuture<>();
3088 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3089 >            checkIncomplete(f);
3090 >            for (int i = k - 1; i >= 0; i--) {
3091 >                fs[i].complete(i);
3092 >                checkCompletedNormally(f, k - 1);
3093 >                int x = (int) CompletableFuture.anyOf(fs).join();
3094 >                assertTrue(i <= x && x <= k - 1);
3095              }
3096          }
3097      }
# Line 3332 | Line 3100 | public class CompletableFutureTest exten
3100       * anyOf result completes exceptionally when any component does.
3101       */
3102      public void testAnyOf_exceptional() throws Exception {
3103 <        for (int k = 0; k < 10; ++k) {
3103 >        for (int k = 0; k < 10; k++) {
3104              CompletableFuture[] fs = new CompletableFuture[k];
3105 <            for (int i = 0; i < k; ++i)
3105 >            CFException[] exs = new CFException[k];
3106 >            for (int i = 0; i < k; i++) {
3107                  fs[i] = new CompletableFuture<>();
3108 +                exs[i] = new CFException();
3109 +            }
3110              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3111              checkIncomplete(f);
3112 <            for (int i = 0; i < k; ++i) {
3113 <                fs[i].completeExceptionally(new CFException());
3114 <                checkCompletedWithWrappedCFException(f);
3112 >            for (int i = 0; i < k; i++) {
3113 >                fs[i].completeExceptionally(exs[i]);
3114 >                checkCompletedWithWrappedException(f, exs[0]);
3115 >                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3116 >            }
3117 >        }
3118 >    }
3119 >
3120 >    public void testAnyOf_exceptional_backwards() throws Exception {
3121 >        for (int k = 0; k < 10; k++) {
3122 >            CompletableFuture[] fs = new CompletableFuture[k];
3123 >            CFException[] exs = new CFException[k];
3124 >            for (int i = 0; i < k; i++) {
3125 >                fs[i] = new CompletableFuture<>();
3126 >                exs[i] = new CFException();
3127 >            }
3128 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3129 >            checkIncomplete(f);
3130 >            for (int i = k - 1; i >= 0; i--) {
3131 >                fs[i].completeExceptionally(exs[i]);
3132 >                checkCompletedWithWrappedException(f, exs[k - 1]);
3133                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3134              }
3135          }
# Line 3359 | Line 3148 | public class CompletableFutureTest exten
3148          Runnable[] throwingActions = {
3149              () -> CompletableFuture.supplyAsync(null),
3150              () -> CompletableFuture.supplyAsync(null, exec),
3151 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
3151 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
3152  
3153              () -> CompletableFuture.runAsync(null),
3154              () -> CompletableFuture.runAsync(null, exec),
# Line 3432 | Line 3221 | public class CompletableFutureTest exten
3221  
3222              () -> f.thenCompose(null),
3223              () -> f.thenComposeAsync(null),
3224 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
3224 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
3225              () -> f.thenComposeAsync(null, exec),
3226  
3227              () -> f.exceptionally(null),
# Line 3464 | Line 3253 | public class CompletableFutureTest exten
3253          assertSame(f, f.toCompletableFuture());
3254      }
3255  
3256 <    /**
3468 <     * whenComplete action executes on normal completion, propagating
3469 <     * source result.
3470 <     */
3471 <    public void testWhenComplete_normalCompletion1() {
3472 <        for (ExecutionMode m : ExecutionMode.values())
3473 <        for (Integer v1 : new Integer[] { 1, null }) {
3474 <
3475 <        final AtomicInteger a = new AtomicInteger();
3476 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3477 <        final CompletableFuture<Integer> g =
3478 <            m.whenComplete(f,
3479 <                           (Integer x, Throwable t) -> {
3480 <                               threadAssertSame(x, v1);
3481 <                               threadAssertNull(t);
3482 <                               a.getAndIncrement();
3483 <                           });
3484 <        f.complete(v1);
3485 <        checkCompletedNormally(f, v1);
3486 <        checkCompletedNormally(g, v1);
3487 <        assertEquals(a.get(), 1);
3488 <        }
3489 <    }
3490 <
3491 <    /**
3492 <     * whenComplete action executes on exceptional completion, propagating
3493 <     * source result.
3494 <     */
3495 <    public void testWhenComplete_exceptionalCompletion() {
3496 <        for (ExecutionMode m : ExecutionMode.values())
3497 <        for (Integer v1 : new Integer[] { 1, null }) {
3256 >    //--- tests of implementation details; not part of official tck ---
3257  
3258 <        final AtomicInteger a = new AtomicInteger();
3259 <        final CFException ex = new CFException();
3260 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3261 <        final CompletableFuture<Integer> g = m.whenComplete
3262 <            (f,
3263 <             (Integer x, Throwable t) -> {
3264 <                threadAssertNull(x);
3506 <                threadAssertSame(t, ex);
3507 <                a.getAndIncrement();
3508 <            });
3509 <        f.completeExceptionally(ex);
3510 <        checkCompletedWithWrappedCFException(f, ex);
3511 <        checkCompletedWithWrappedCFException(g, ex);
3512 <        assertEquals(a.get(), 1);
3513 <        }
3258 >    Object resultOf(CompletableFuture<?> f) {
3259 >        try {
3260 >            java.lang.reflect.Field resultField
3261 >                = CompletableFuture.class.getDeclaredField("result");
3262 >            resultField.setAccessible(true);
3263 >            return resultField.get(f);
3264 >        } catch (Throwable t) { throw new AssertionError(t); }
3265      }
3266  
3267 <    /**
3268 <     * If a whenComplete action throws an exception when triggered by
3518 <     * a normal completion, it completes exceptionally
3519 <     */
3520 <    public void testWhenComplete_actionFailed() {
3267 >    public void testExceptionPropagationReusesResultObject() {
3268 >        if (!testImplementationDetails) return;
3269          for (ExecutionMode m : ExecutionMode.values())
3270 <        for (Integer v1 : new Integer[] { 1, null }) {
3523 <
3270 >    {
3271          final CFException ex = new CFException();
3272 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3273 <        final CompletableFuture<Integer> g = m.whenComplete
3527 <            (f,
3528 <             (Integer x, Throwable t) -> {
3529 <                threadAssertSame(x, v1);
3530 <                threadAssertNull(t);
3531 <                throw ex;
3532 <            });
3533 <        f.complete(v1);
3534 <        checkCompletedNormally(f, v1);
3535 <        checkCompletedWithWrappedCFException(g, ex);
3536 <        }
3537 <    }
3272 >        final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3273 >        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3274  
3275 <    /**
3276 <     * If a whenComplete action throws an exception when triggered by
3541 <     * a source completion that also throws an exception, the source
3542 <     * exception takes precedence.
3543 <     */
3544 <    public void testWhenComplete_actionFailedSourceFailed() {
3545 <        for (ExecutionMode m : ExecutionMode.values())
3546 <        for (Integer v1 : new Integer[] { 1, null }) {
3547 <
3548 <        final CFException ex1 = new CFException();
3549 <        final CFException ex2 = new CFException();
3550 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3551 <        final CompletableFuture<Integer> g = m.whenComplete
3552 <            (f,
3553 <             (Integer x, Throwable t) -> {
3554 <                threadAssertSame(t, ex1);
3555 <                threadAssertNull(x);
3556 <                throw ex2;
3557 <            });
3558 <        f.completeExceptionally(ex1);
3559 <        checkCompletedWithWrappedCFException(f, ex1);
3560 <        checkCompletedWithWrappedCFException(g, ex1);
3561 <        }
3562 <    }
3275 >        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3276 >            = new ArrayList<>();
3277  
3278 <    /**
3279 <     * handleAsync action completes normally with function value on
3280 <     * either normal or exceptional completion of source
3567 <     */
3568 <    public void testHandleAsync() {
3569 <        CompletableFuture<Integer> f, g;
3570 <        IntegerHandler r;
3278 >        funs.add((y) -> m.thenRun(y, new Noop(m)));
3279 >        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3280 >        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3281  
3282 <        f = new CompletableFuture<>();
3283 <        g = f.handleAsync(r = new IntegerHandler());
3284 <        assertFalse(r.ran);
3575 <        f.completeExceptionally(new CFException());
3576 <        checkCompletedWithWrappedCFException(f);
3577 <        checkCompletedNormally(g, three);
3578 <        assertTrue(r.ran);
3282 >        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3283 >        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3284 >        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3285  
3286 <        f = new CompletableFuture<>();
3287 <        g = f.handleAsync(r = new IntegerHandler());
3288 <        assertFalse(r.ran);
3583 <        f.completeExceptionally(new CFException());
3584 <        checkCompletedWithWrappedCFException(f);
3585 <        checkCompletedNormally(g, three);
3586 <        assertTrue(r.ran);
3286 >        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3287 >        funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3288 >        funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3289  
3290 <        f = new CompletableFuture<>();
3589 <        g = f.handleAsync(r = new IntegerHandler());
3590 <        assertFalse(r.ran);
3591 <        f.complete(one);
3592 <        checkCompletedNormally(f, one);
3593 <        checkCompletedNormally(g, two);
3594 <        assertTrue(r.ran);
3290 >        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3291  
3292 <        f = new CompletableFuture<>();
3597 <        g = f.handleAsync(r = new IntegerHandler());
3598 <        assertFalse(r.ran);
3599 <        f.complete(one);
3600 <        checkCompletedNormally(f, one);
3601 <        checkCompletedNormally(g, two);
3602 <        assertTrue(r.ran);
3603 <    }
3292 >        funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3293  
3294 <    /**
3295 <     * handleAsync action with Executor completes normally with
3607 <     * function value on either normal or exceptional completion of
3608 <     * source
3609 <     */
3610 <    public void testHandleAsync2() {
3611 <        CompletableFuture<Integer> f, g;
3612 <        ThreadExecutor exec = new ThreadExecutor();
3613 <        IntegerHandler r;
3294 >        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3295 >        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3296  
3297 <        f = new CompletableFuture<>();
3298 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3299 <        assertFalse(r.ran);
3300 <        f.completeExceptionally(new CFException());
3301 <        checkCompletedWithWrappedCFException(f);
3302 <        checkCompletedNormally(g, three);
3303 <        assertTrue(r.ran);
3297 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3298 >                 fun : funs) {
3299 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3300 >            f.completeExceptionally(ex);
3301 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3302 >            checkCompletedWithWrappedException(src, ex);
3303 >            CompletableFuture<?> dep = fun.apply(src);
3304 >            checkCompletedWithWrappedException(dep, ex);
3305 >            assertSame(resultOf(src), resultOf(dep));
3306 >        }
3307  
3308 <        f = new CompletableFuture<>();
3309 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3310 <        assertFalse(r.ran);
3311 <        f.completeExceptionally(new CFException());
3312 <        checkCompletedWithWrappedCFException(f);
3313 <        checkCompletedNormally(g, three);
3314 <        assertTrue(r.ran);
3308 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3309 >                 fun : funs) {
3310 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3311 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3312 >            CompletableFuture<?> dep = fun.apply(src);
3313 >            f.completeExceptionally(ex);
3314 >            checkCompletedWithWrappedException(src, ex);
3315 >            checkCompletedWithWrappedException(dep, ex);
3316 >            assertSame(resultOf(src), resultOf(dep));
3317 >        }
3318  
3319 <        f = new CompletableFuture<>();
3320 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3321 <        assertFalse(r.ran);
3322 <        f.complete(one);
3323 <        checkCompletedNormally(f, one);
3324 <        checkCompletedNormally(g, two);
3325 <        assertTrue(r.ran);
3319 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3320 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3321 >                 fun : funs) {
3322 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3323 >            f.cancel(mayInterruptIfRunning);
3324 >            checkCancelled(f);
3325 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3326 >            checkCompletedWithWrappedCancellationException(src);
3327 >            CompletableFuture<?> dep = fun.apply(src);
3328 >            checkCompletedWithWrappedCancellationException(dep);
3329 >            assertSame(resultOf(src), resultOf(dep));
3330 >        }
3331  
3332 <        f = new CompletableFuture<>();
3333 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3334 <        assertFalse(r.ran);
3335 <        f.complete(one);
3336 <        checkCompletedNormally(f, one);
3337 <        checkCompletedNormally(g, two);
3338 <        assertTrue(r.ran);
3339 <    }
3332 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3333 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3334 >                 fun : funs) {
3335 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3336 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3337 >            CompletableFuture<?> dep = fun.apply(src);
3338 >            f.cancel(mayInterruptIfRunning);
3339 >            checkCancelled(f);
3340 >            checkCompletedWithWrappedCancellationException(src);
3341 >            checkCompletedWithWrappedCancellationException(dep);
3342 >            assertSame(resultOf(src), resultOf(dep));
3343 >        }
3344 >    }}
3345  
3346   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines