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.33 by jsr166, Sun Jun 1 20:40:13 2014 UTC vs.
Revision 1.90 by jsr166, Tue Jun 17 18:09:28 2014 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines