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.34 by jsr166, Sun Jun 1 21:17:05 2014 UTC vs.
Revision 1.78 by jsr166, Sat Jun 7 23:32:17 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; }
384 >        void assertNotInvoked() { assertEquals(0, invocationCount); }
385 >        void assertInvoked() { assertEquals(1, invocationCount); }
386      }
387  
388 <    static final class FailingSupplier implements Supplier<Integer> {
389 <        boolean ran;
390 <        public Integer get() { ran = true; throw new CFException(); }
391 <    }
392 <    static final class FailingConsumer implements Consumer<Integer> {
393 <        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(); }
364 <    }
365 <
366 <    static final class CompletableFutureInc
367 <        implements Function<Integer, CompletableFuture<Integer>> {
368 <        boolean ran;
369 <        public CompletableFuture<Integer> apply(Integer x) {
370 <            ran = true;
371 <            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);
586 <    }
587 <
588 <    /**
589 <     * thenRun result completes exceptionally if source cancelled
590 <     */
591 <    public void testThenRun4() {
592 <        CompletableFuture<Integer> f;
593 <        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);
605 <    }
606 <
607 <    /**
608 <     * thenApply result completes normally after normal completion of source
609 <     */
610 <    public void testThenApply() {
611 <        CompletableFuture<Integer> f = new CompletableFuture<>();
612 <        CompletableFuture<Integer> g = f.thenApply(inc);
613 <        f.complete(one);
614 <        checkCompletedNormally(g, two);
615 <    }
616 <
617 <    /**
618 <     * thenApply result completes exceptionally after exceptional
619 <     * completion of source
620 <     */
621 <    public void testThenApply2() {
622 <        CompletableFuture<Integer> f = new CompletableFuture<>();
623 <        CompletableFuture<Integer> g = f.thenApply(inc);
624 <        f.completeExceptionally(new CFException());
625 <        checkCompletedWithWrappedCFException(g);
626 <    }
627 <
628 <    /**
629 <     * thenApply result completes exceptionally if action does
630 <     */
631 <    public void testThenApply3() {
632 <        CompletableFuture<Integer> f = new CompletableFuture<>();
633 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
634 <        f.complete(one);
635 <        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 <     * thenApply result completes exceptionally if source cancelled
438 <     */
439 <    public void testThenApply4() {
440 <        CompletableFuture<Integer> f = new CompletableFuture<>();
441 <        CompletableFuture<Integer> g = f.thenApply(inc);
644 <        assertTrue(f.cancel(true));
645 <        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 <     * thenAccept result completes normally after normal completion of source
446 <     */
447 <    public void testThenAccept() {
448 <        CompletableFuture<Integer> f = new CompletableFuture<>();
449 <        IncAction r = new IncAction();
450 <        CompletableFuture<Void> g = f.thenAccept(r);
451 <        f.complete(one);
656 <        checkCompletedNormally(g, null);
657 <        assertEquals(r.value, 2);
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 <     * thenAccept result completes exceptionally after exceptional
456 <     * completion of source
457 <     */
458 <    public void testThenAccept2() {
459 <        CompletableFuture<Integer> f = new CompletableFuture<>();
460 <        IncAction r = new IncAction();
461 <        CompletableFuture<Void> g = f.thenAccept(r);
668 <        f.completeExceptionally(new CFException());
669 <        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 <     * thenAccept result completes exceptionally if action does
466 <     */
467 <    public void testThenAccept3() {
468 <        CompletableFuture<Integer> f = new CompletableFuture<>();
677 <        FailingConsumer r = new FailingConsumer();
678 <        CompletableFuture<Void> g = f.thenAccept(r);
679 <        f.complete(one);
680 <        checkCompletedWithWrappedCFException(g);
681 <        assertTrue(r.ran);
464 >    class Noop extends CheckedAction implements Runnable {
465 >        Noop(ExecutionMode m) { super(m); }
466 >        public void run() {
467 >            invoked();
468 >        }
469      }
470  
471 <    /**
472 <     * thenAccept result completes exceptionally if source cancelled
473 <     */
474 <    public void testThenAccept4() {
475 <        CompletableFuture<Integer> f = new CompletableFuture<>();
476 <        IncAction r = new IncAction();
477 <        CompletableFuture<Void> g = f.thenAccept(r);
478 <        assertTrue(f.cancel(true));
692 <        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 <     * thenCombine result completes normally after normal completion
483 <     * of sources
484 <     */
485 <    public void testThenCombine() {
486 <        CompletableFuture<Integer> f, g, h;
487 <
488 <        f = new CompletableFuture<>();
489 <        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);
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 <     * thenCombine result completes exceptionally after exceptional
494 <     * completion of either source
495 <     */
496 <    public void testThenCombine2() {
497 <        CompletableFuture<Integer> f, g, h;
498 <
499 <        f = new CompletableFuture<>();
500 <        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);
748 <
749 <        f = new CompletableFuture<>();
750 <        g = new CompletableFuture<>();
751 <        f.complete(3);
752 <        g.completeExceptionally(new CFException());
753 <        h = f.thenCombine(g, subtract);
754 <        checkCompletedWithWrappedCFException(h);
755 <
756 <        f = new CompletableFuture<>();
757 <        g = new CompletableFuture<>();
758 <        f.completeExceptionally(new CFException());
759 <        g.complete(3);
760 <        h = f.thenCombine(g, subtract);
761 <        checkCompletedWithWrappedCFException(h);
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 <     * thenCombine result completes exceptionally if action does
505 <     */
506 <    public void testThenCombine3() {
507 <        CompletableFuture<Integer> f = new CompletableFuture<>();
508 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
509 <        FailingBiFunction r = new FailingBiFunction();
510 <        CompletableFuture<Integer> g = f.thenCombine(f2, r);
511 <        f.complete(one);
773 <        checkIncomplete(g);
774 <        assertFalse(r.ran);
775 <        f2.complete(two);
776 <        checkCompletedWithWrappedCFException(g);
777 <        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 <     * thenCombine result completes exceptionally if either source cancelled
516 <     */
517 <    public void testThenCombine4() {
518 <        CompletableFuture<Integer> f, g, h;
519 <
520 <        f = new CompletableFuture<>();
521 <        g = new CompletableFuture<>();
522 <        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);
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 <     * thenAcceptBoth result completes normally after normal
527 <     * completion of sources
528 <     */
529 <    public void testThenAcceptBoth() {
530 <        CompletableFuture<Integer> f, g;
816 <        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);
836 <
837 <        f = new CompletableFuture<>();
838 <        g = new CompletableFuture<>();
839 <        g.complete(1);
840 <        f.complete(3);
841 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
842 <        checkCompletedNormally(h, null);
843 <        assertEquals(r.value, 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  
846    /**
847     * thenAcceptBoth result completes exceptionally after exceptional
848     * completion of either source
849     */
850    public void testThenAcceptBoth2() {
851        CompletableFuture<Integer> f, g;
852        CompletableFuture<Void> h;
853        SubtractAction r;
854
855        f = new CompletableFuture<>();
856        g = new CompletableFuture<>();
857        h = f.thenAcceptBoth(g, r = new SubtractAction());
858        f.completeExceptionally(new CFException());
859        checkIncomplete(h);
860        g.complete(1);
861        checkCompletedWithWrappedCFException(h);
533  
534 <        f = new CompletableFuture<>();
535 <        g = new CompletableFuture<>();
536 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
537 <        g.completeExceptionally(new CFException());
538 <        checkIncomplete(h);
539 <        f.complete(3);
540 <        checkCompletedWithWrappedCFException(h);
541 <
542 <        f = new CompletableFuture<>();
543 <        g = new CompletableFuture<>();
544 <        f.complete(3);
874 <        g.completeExceptionally(new CFException());
875 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
876 <        checkCompletedWithWrappedCFException(h);
877 <
878 <        f = new CompletableFuture<>();
879 <        g = new CompletableFuture<>();
880 <        f.completeExceptionally(new CFException());
881 <        g.complete(3);
882 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
883 <        checkCompletedWithWrappedCFException(h);
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 <     * thenAcceptBoth result completes exceptionally if action does
549 <     */
550 <    public void testThenAcceptBoth3() {
551 <        CompletableFuture<Integer> f, g;
552 <        CompletableFuture<Void> h;
553 <        FailingBiConsumer r;
554 <
555 <        f = new CompletableFuture<>();
895 <        g = new CompletableFuture<>();
896 <        h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
897 <        f.complete(3);
898 <        checkIncomplete(h);
899 <        g.complete(1);
900 <        checkCompletedWithWrappedCFException(h);
901 <
902 <        f = new CompletableFuture<>();
903 <        g = new CompletableFuture<>();
904 <        f.complete(3);
905 <        g.complete(1);
906 <        h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
907 <        checkCompletedWithWrappedCFException(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 exceptionally if either source cancelled
560 <     */
561 <    public void testThenAcceptBoth4() {
562 <        CompletableFuture<Integer> f, g;
563 <        CompletableFuture<Void> h;
564 <        SubtractAction r;
917 <
918 <        f = new CompletableFuture<>();
919 <        g = new CompletableFuture<>();
920 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
921 <        assertTrue(f.cancel(true));
922 <        checkIncomplete(h);
923 <        g.complete(1);
924 <        checkCompletedWithWrappedCancellationException(h);
925 <
926 <        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);
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 <        assertTrue(f.cancel(true));
569 <        g.complete(3);
945 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
946 <        checkCompletedWithWrappedCancellationException(h);
566 >        public void execute(Runnable r) {
567 >            count.getAndIncrement();
568 >            new Thread(tg, r).start();
569 >        }
570      }
571  
572      /**
573       * Permits the testing of parallel code for the 3 different
574 <     * execution modes without repeating all the testing code.
574 >     * execution modes without copy/pasting all the test methods.
575       */
576      enum ExecutionMode {
577          DEFAULT {
578 +            public void checkExecutionMode() {
579 +                assertFalse(ThreadExecutor.startedCurrentThread());
580 +                assertNull(ForkJoinTask.getPool());
581 +            }
582 +            public CompletableFuture<Void> runAsync(Runnable a) {
583 +                throw new UnsupportedOperationException();
584 +            }
585 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
586 +                throw new UnsupportedOperationException();
587 +            }
588 +            public <T> CompletableFuture<Void> thenRun
589 +                (CompletableFuture<T> f, Runnable a) {
590 +                return f.thenRun(a);
591 +            }
592 +            public <T> CompletableFuture<Void> thenAccept
593 +                (CompletableFuture<T> f, Consumer<? super T> a) {
594 +                return f.thenAccept(a);
595 +            }
596 +            public <T,U> CompletableFuture<U> thenApply
597 +                (CompletableFuture<T> f, Function<? super T,U> a) {
598 +                return f.thenApply(a);
599 +            }
600 +            public <T,U> CompletableFuture<U> thenCompose
601 +                (CompletableFuture<T> f,
602 +                 Function<? super T,? extends CompletionStage<U>> a) {
603 +                return f.thenCompose(a);
604 +            }
605 +            public <T,U> CompletableFuture<U> handle
606 +                (CompletableFuture<T> f,
607 +                 BiFunction<? super T,Throwable,? extends U> a) {
608 +                return f.handle(a);
609 +            }
610 +            public <T> CompletableFuture<T> whenComplete
611 +                (CompletableFuture<T> f,
612 +                 BiConsumer<? super T,? super Throwable> a) {
613 +                return f.whenComplete(a);
614 +            }
615              public <T,U> CompletableFuture<Void> runAfterBoth
616 <                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable r) {
617 <                return f.runAfterBoth(g, r);
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 <        DEFAULT_ASYNC {
651 >        ASYNC {
652 >            public void checkExecutionMode() {
653 >                assertSame(ForkJoinPool.commonPool(),
654 >                           ForkJoinTask.getPool());
655 >            }
656 >            public CompletableFuture<Void> runAsync(Runnable a) {
657 >                return CompletableFuture.runAsync(a);
658 >            }
659 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
660 >                return CompletableFuture.supplyAsync(a);
661 >            }
662 >            public <T> CompletableFuture<Void> thenRun
663 >                (CompletableFuture<T> f, Runnable a) {
664 >                return f.thenRunAsync(a);
665 >            }
666 >            public <T> CompletableFuture<Void> thenAccept
667 >                (CompletableFuture<T> f, Consumer<? super T> a) {
668 >                return f.thenAcceptAsync(a);
669 >            }
670 >            public <T,U> CompletableFuture<U> thenApply
671 >                (CompletableFuture<T> f, Function<? super T,U> a) {
672 >                return f.thenApplyAsync(a);
673 >            }
674 >            public <T,U> CompletableFuture<U> thenCompose
675 >                (CompletableFuture<T> f,
676 >                 Function<? super T,? extends CompletionStage<U>> a) {
677 >                return f.thenComposeAsync(a);
678 >            }
679 >            public <T,U> CompletableFuture<U> handle
680 >                (CompletableFuture<T> f,
681 >                 BiFunction<? super T,Throwable,? extends U> a) {
682 >                return f.handleAsync(a);
683 >            }
684 >            public <T> CompletableFuture<T> whenComplete
685 >                (CompletableFuture<T> f,
686 >                 BiConsumer<? super T,? super Throwable> a) {
687 >                return f.whenCompleteAsync(a);
688 >            }
689              public <T,U> CompletableFuture<Void> runAfterBoth
690 <                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable r) {
691 <                return f.runAfterBothAsync(g, r);
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          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 r) {
764 <                return f.runAfterBothAsync(g, r, new ThreadExecutor());
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 +        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 r);
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 <     * runAfterBoth result completes normally after normal
842 <     * completion of sources
841 >     * exceptionally action is not invoked when source completes
842 >     * normally, and source result is propagated
843       */
844 <    public void testRunAfterBoth_normalCompletion1() {
845 <        for (ExecutionMode m : ExecutionMode.values())
844 >    public void testExceptionally_normalCompletion() {
845 >        for (boolean createIncomplete : new boolean[] { true, false })
846          for (Integer v1 : new Integer[] { 1, null })
847 <        for (Integer v2 : new Integer[] { 2, null }) {
848 <
847 >    {
848 >        final AtomicInteger a = new AtomicInteger(0);
849          final CompletableFuture<Integer> f = new CompletableFuture<>();
850 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
851 <        final Noop r = new Noop();
852 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
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.complete(v1);
994 <        checkIncomplete(h);
995 <        assertFalse(r.ran);
996 <        g.complete(v2);
997 <
998 <        checkCompletedNormally(h, null);
999 <        assertTrue(r.ran);
859 >        checkCompletedNormally(g, v1);
860          checkCompletedNormally(f, v1);
861 <        checkCompletedNormally(g, v2);
862 <        }
1003 <    }
861 >        assertEquals(0, a.get());
862 >    }}
863  
864 <    public void testRunAfterBoth_normalCompletion2() {
865 <        for (ExecutionMode m : ExecutionMode.values())
864 >    /**
865 >     * exceptionally action completes with function value on source
866 >     * exception
867 >     */
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 = m.runAfterBoth(f, g, r);
878 <
879 <        g.complete(v2);
880 <        checkIncomplete(h);
881 <        assertFalse(r.ran);
882 <        f.complete(v1);
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);
1023 <        checkCompletedNormally(g, v2);
1024 <        }
1025 <    }
885 >        checkCompletedNormally(g, v1);
886 >        assertEquals(1, a.get());
887 >    }}
888  
889 <    public void testRunAfterBoth_normalCompletion3() {
890 <        for (ExecutionMode m : ExecutionMode.values())
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();
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 <        f.complete(v1);
913 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
914 <
915 <        checkCompletedNormally(h, null);
1041 <        assertTrue(r.ran);
1042 <        checkCompletedNormally(f, v1);
1043 <        checkCompletedNormally(g, v2);
1044 <        }
1045 <    }
1046 <
1047 <    public void testRunAfterBoth_normalCompletion4() {
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 <        f.complete(v1);
926 <        g.complete(v2);
927 <        final CompletableFuture<Void> h = m.runAfterBoth(f, 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);
1061 <        assertTrue(r.ran);
933 >        checkCompletedNormally(g, v1);
934          checkCompletedNormally(f, v1);
935 <        checkCompletedNormally(g, v2);
936 <        }
1065 <    }
935 >        assertEquals(1, a.get());
936 >    }}
937  
938      /**
939 <     * runAfterBoth result completes exceptionally after exceptional
940 <     * completion of either source
939 >     * whenComplete action executes on exceptional completion, propagating
940 >     * source result.
941       */
942 <    public void testRunAfterBoth_exceptionalCompletion1() {
942 >    public void testWhenComplete_exceptionalCompletion() {
943          for (ExecutionMode m : ExecutionMode.values())
944 <        for (Integer v1 : new Integer[] { 1, null }) {
945 <
946 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
947 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1077 <        final Noop r = new Noop();
1078 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
944 >        for (boolean createIncomplete : new boolean[] { true, false })
945 >        for (Integer v1 : new Integer[] { 1, null })
946 >    {
947 >        final AtomicInteger a = new AtomicInteger(0);
948          final CFException ex = new CFException();
949 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
950 +        if (!createIncomplete) f.completeExceptionally(ex);
951 +        final CompletableFuture<Integer> g = m.whenComplete
952 +            (f,
953 +             (Integer x, Throwable t) -> {
954 +                m.checkExecutionMode();
955 +                threadAssertNull(x);
956 +                threadAssertSame(t, ex);
957 +                a.getAndIncrement();
958 +            });
959 +        if (createIncomplete) f.completeExceptionally(ex);
960 +
961 +        checkCompletedWithWrappedException(g, ex);
962 +        checkCompletedExceptionally(f, ex);
963 +        assertEquals(1, a.get());
964 +    }}
965  
966 <        f.completeExceptionally(ex);
967 <        checkIncomplete(h);
968 <        g.complete(v1);
969 <
970 <        checkCompletedWithWrappedCFException(h, ex);
1086 <        checkCompletedWithWrappedCFException(f, ex);
1087 <        assertFalse(r.ran);
1088 <        checkCompletedNormally(g, v1);
1089 <        }
1090 <    }
1091 <
1092 <    public void testRunAfterBoth_exceptionalCompletion2() {
966 >    /**
967 >     * whenComplete action executes on cancelled source, propagating
968 >     * CancellationException.
969 >     */
970 >    public void testWhenComplete_sourceCancelled() {
971          for (ExecutionMode m : ExecutionMode.values())
972 <        for (Integer v1 : new Integer[] { 1, null }) {
973 <
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 = m.runAfterBoth(f, 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 <        g.completeExceptionally(ex);
989 <        checkIncomplete(h);
990 <        f.complete(v1);
991 <
1106 <        checkCompletedWithWrappedCFException(h, ex);
1107 <        checkCompletedWithWrappedCFException(g, ex);
1108 <        assertFalse(r.ran);
1109 <        checkCompletedNormally(f, v1);
1110 <        }
1111 <    }
988 >        checkCompletedWithWrappedCancellationException(g);
989 >        checkCancelled(f);
990 >        assertEquals(1, a.get());
991 >    }}
992  
993 <    public void testRunAfterBoth_exceptionalCompletion3() {
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 CompletableFuture<Integer> f = new CompletableFuture<>();
1118 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1119 <        final Noop r = new Noop();
1000 >        for (Integer v1 : new Integer[] { 1, null })
1001 >    {
1002 >        final AtomicInteger a = new AtomicInteger(0);
1003          final CFException ex = new CFException();
1004 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1005 +        if (!createIncomplete) assertTrue(f.complete(v1));
1006 +        final CompletableFuture<Integer> g = m.whenComplete
1007 +            (f,
1008 +             (Integer x, Throwable t) -> {
1009 +                m.checkExecutionMode();
1010 +                threadAssertSame(x, v1);
1011 +                threadAssertNull(t);
1012 +                a.getAndIncrement();
1013 +                throw ex;
1014 +            });
1015 +        if (createIncomplete) assertTrue(f.complete(v1));
1016  
1017 <        g.completeExceptionally(ex);
1123 <        f.complete(v1);
1124 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1125 <
1126 <        checkCompletedWithWrappedCFException(h, ex);
1127 <        checkCompletedWithWrappedCFException(g, ex);
1128 <        assertFalse(r.ran);
1017 >        checkCompletedWithWrappedException(g, ex);
1018          checkCompletedNormally(f, v1);
1019 <        }
1020 <    }
1019 >        assertEquals(1, a.get());
1020 >    }}
1021  
1022 <    public void testRunAfterBoth_exceptionalCompletion4() {
1022 >    /**
1023 >     * If a whenComplete action throws an exception when triggered by
1024 >     * a source completion that also throws an exception, the source
1025 >     * exception takes precedence.
1026 >     */
1027 >    public void testWhenComplete_actionFailedSourceFailed() {
1028 >        for (boolean createIncomplete : new boolean[] { true, false })
1029          for (ExecutionMode m : ExecutionMode.values())
1030 <        for (Integer v1 : new Integer[] { 1, null }) {
1031 <
1030 >        for (Integer v1 : new Integer[] { 1, null })
1031 >    {
1032 >        final AtomicInteger a = new AtomicInteger(0);
1033 >        final CFException ex1 = new CFException();
1034 >        final CFException ex2 = new CFException();
1035          final CompletableFuture<Integer> f = new CompletableFuture<>();
1138        final CompletableFuture<Integer> g = new CompletableFuture<>();
1139        final Noop r = new Noop();
1140        final CFException ex = new CFException();
1036  
1037 <        f.completeExceptionally(ex);
1038 <        g.complete(v1);
1039 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1040 <
1041 <        checkCompletedWithWrappedCFException(h, ex);
1042 <        checkCompletedWithWrappedCFException(f, ex);
1043 <        assertFalse(r.ran);
1044 <        checkCompletedNormally(g, v1);
1045 <        }
1046 <    }
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 <     * runAfterBoth result completes exceptionally if action does
1055 >     * handle action completes normally with function value on normal
1056 >     * completion of source
1057       */
1058 <    public void testRunAfterBoth_actionFailed1() {
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 }) {
1160 <
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 = m.runAfterBoth(f, g, r);
1067 <
1068 <        f.complete(v1);
1069 <        checkIncomplete(h);
1070 <        g.complete(v2);
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 <        }
1174 <    }
1079 >        assertEquals(1, a.get());
1080 >    }}
1081  
1082 <    public void testRunAfterBoth_actionFailed2() {
1082 >    /**
1083 >     * handle action completes normally with function value on
1084 >     * exceptional completion of source
1085 >     */
1086 >    public void testHandle_exceptionalCompletion() {
1087          for (ExecutionMode m : ExecutionMode.values())
1088 +        for (boolean createIncomplete : new boolean[] { true, false })
1089          for (Integer v1 : new Integer[] { 1, null })
1090 <        for (Integer v2 : new Integer[] { 2, null }) {
1180 <
1090 >    {
1091          final CompletableFuture<Integer> f = new CompletableFuture<>();
1092 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1093 <        final FailingNoop r = new FailingNoop();
1094 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1095 <
1096 <        g.complete(v2);
1097 <        checkIncomplete(h);
1098 <        f.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  
1106 <        checkCompletedWithWrappedCFException(h);
1107 <        checkCompletedNormally(f, v1);
1108 <        checkCompletedNormally(g, v2);
1109 <        }
1194 <    }
1106 >        checkCompletedNormally(g, v1);
1107 >        checkCompletedExceptionally(f, ex);
1108 >        assertEquals(1, a.get());
1109 >    }}
1110  
1111      /**
1112 <     * runAfterBoth result completes exceptionally if either source cancelled
1112 >     * handle action completes normally with function value on
1113 >     * cancelled source
1114       */
1115 <    public void testRunAfterBoth_sourceCancelled1() {
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();
1124 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1125 <
1126 <        assertTrue(f.cancel(mayInterruptIfRunning));
1127 <        checkIncomplete(h);
1128 <        g.complete(v1);
1122 >        final AtomicInteger a = new AtomicInteger(0);
1123 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1124 >        final CompletableFuture<Integer> g = m.handle
1125 >            (f,
1126 >             (Integer x, Throwable t) -> {
1127 >                m.checkExecutionMode();
1128 >                threadAssertNull(x);
1129 >                threadAssertTrue(t instanceof CancellationException);
1130 >                a.getAndIncrement();
1131 >                return v1;
1132 >            });
1133 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1134  
1213        checkCompletedWithWrappedCancellationException(h);
1214        checkCancelled(f);
1215        assertFalse(r.ran);
1135          checkCompletedNormally(g, v1);
1136 <        }
1137 <    }
1136 >        checkCancelled(f);
1137 >        assertEquals(1, a.get());
1138 >    }}
1139  
1140 <    public void testRunAfterBoth_sourceCancelled2() {
1140 >    /**
1141 >     * handle result completes exceptionally if action does
1142 >     */
1143 >    public void testHandle_sourceFailedActionFailed() {
1144          for (ExecutionMode m : ExecutionMode.values())
1145 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1146 <        for (Integer v1 : new Integer[] { 1, null }) {
1224 <
1145 >        for (boolean createIncomplete : new boolean[] { true, false })
1146 >    {
1147          final CompletableFuture<Integer> f = new CompletableFuture<>();
1148 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1149 <        final Noop r = new Noop();
1150 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1151 <
1152 <        assertTrue(g.cancel(mayInterruptIfRunning));
1153 <        checkIncomplete(h);
1154 <        f.complete(v1);
1155 <
1156 <        checkCompletedWithWrappedCancellationException(h);
1157 <        checkCancelled(g);
1158 <        assertFalse(r.ran);
1159 <        checkCompletedNormally(f, v1);
1160 <        }
1161 <    }
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 testRunAfterBoth_sourceCancelled3() {
1168 >    public void testHandle_sourceCompletedNormallyActionFailed() {
1169          for (ExecutionMode m : ExecutionMode.values())
1170 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1171 <        for (Integer v1 : new Integer[] { 1, null }) {
1172 <
1170 >        for (boolean createIncomplete : new boolean[] { true, false })
1171 >        for (Integer v1 : new Integer[] { 1, null })
1172 >    {
1173          final CompletableFuture<Integer> f = new CompletableFuture<>();
1174 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1175 <        final Noop r = new Noop();
1176 <
1177 <        assertTrue(g.cancel(mayInterruptIfRunning));
1178 <        f.complete(v1);
1179 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
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 <        checkCompletedWithWrappedCancellationException(h);
1255 <        checkCancelled(g);
1256 <        assertFalse(r.ran);
1188 >        checkCompletedWithWrappedException(g, ex);
1189          checkCompletedNormally(f, v1);
1190 <        }
1191 <    }
1260 <
1261 <    public void testRunAfterBoth_sourceCancelled4() {
1262 <        for (ExecutionMode m : ExecutionMode.values())
1263 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1264 <        for (Integer v1 : new Integer[] { 1, null }) {
1265 <
1266 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1267 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1268 <        final Noop r = new Noop();
1269 <
1270 <        assertTrue(f.cancel(mayInterruptIfRunning));
1271 <        g.complete(v1);
1272 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1273 <
1274 <        checkCompletedWithWrappedCancellationException(h);
1275 <        checkCancelled(f);
1276 <        assertFalse(r.ran);
1277 <        checkCompletedNormally(g, v1);
1278 <        }
1279 <    }
1190 >        assertEquals(1, a.get());
1191 >    }}
1192  
1193      /**
1194 <     * applyToEither result completes normally after normal completion
1283 <     * of either source
1194 >     * runAsync completes after running Runnable
1195       */
1196 <    public void testApplyToEither() {
1197 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1198 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1199 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1200 <        f.complete(one);
1201 <        checkCompletedNormally(g, two);
1202 <        f2.complete(one);
1203 <        checkCompletedNormally(g, two);
1204 <
1205 <        f = new CompletableFuture<>();
1206 <        f.complete(one);
1207 <        f2 = new CompletableFuture<>();
1208 <        g = f.applyToEither(f2, inc);
1298 <        checkCompletedNormally(g, two);
1299 <    }
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 <     * applyToEither result completes exceptionally after exceptional
1303 <     * completion of either source
1211 >     * failing runAsync completes exceptionally after running Runnable
1212       */
1213 <    public void testApplyToEither2() {
1214 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1215 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1216 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1217 <        f.completeExceptionally(new CFException());
1218 <        f2.complete(one);
1219 <        checkCompletedWithWrappedCFException(g);
1220 <
1221 <        f = new CompletableFuture<>();
1222 <        f2 = new CompletableFuture<>();
1223 <        f2.completeExceptionally(new CFException());
1224 <        g = f.applyToEither(f2, inc);
1317 <        checkCompletedWithWrappedCFException(g);
1318 <    }
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 <     * applyToEither result completes exceptionally if action does
1227 >     * supplyAsync completes with result of supplier
1228       */
1229 <    public void testApplyToEither3() {
1230 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1231 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1232 <        FailingFunction r = new FailingFunction();
1233 <        CompletableFuture<Integer> g = f.applyToEither(f2, r);
1234 <        f2.complete(two);
1235 <        checkCompletedWithWrappedCFException(g);
1236 <    }
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 <     * applyToEither result completes exceptionally if either source cancelled
1245 >     * Failing supplyAsync completes exceptionally
1246       */
1247 <    public void testApplyToEither4() {
1248 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1249 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1250 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1251 <        assertTrue(f.cancel(true));
1252 <        checkCompletedWithWrappedCancellationException(g);
1253 <        f = new CompletableFuture<>();
1254 <        f2 = new CompletableFuture<>();
1255 <        assertTrue(f2.cancel(true));
1256 <        checkCompletedWithWrappedCancellationException(g);
1257 <    }
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 >    // seq completion methods
1261  
1262      /**
1263 <     * acceptEither result completes normally after normal completion
1349 <     * of either source
1263 >     * thenRun result completes normally after normal completion of source
1264       */
1265 <    public void testAcceptEither() {
1266 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1267 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1268 <        IncAction r = new IncAction();
1269 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1270 <        f.complete(one);
1271 <        checkCompletedNormally(g, null);
1272 <        f2.complete(one);
1273 <        checkCompletedNormally(g, null);
1274 <        assertEquals(r.value, 2);
1265 >    public void testThenRun_normalCompletion() {
1266 >        for (ExecutionMode m : ExecutionMode.values())
1267 >        for (boolean createIncomplete : new boolean[] { true, false })
1268 >        for (Integer v1 : new Integer[] { 1, null })
1269 >    {
1270 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1271 >        final Noop r = new Noop(m);
1272 >        if (!createIncomplete) assertTrue(f.complete(v1));
1273 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1274 >        if (createIncomplete) {
1275 >            checkIncomplete(g);
1276 >            assertTrue(f.complete(v1));
1277 >        }
1278  
1362        r = new IncAction();
1363        f = new CompletableFuture<>();
1364        f.complete(one);
1365        f2 = new CompletableFuture<>();
1366        g = f.acceptEither(f2, r);
1279          checkCompletedNormally(g, null);
1280 <        assertEquals(r.value, 2);
1281 <    }
1280 >        checkCompletedNormally(f, v1);
1281 >        r.assertInvoked();
1282 >    }}
1283  
1284      /**
1285 <     * acceptEither result completes exceptionally after exceptional
1286 <     * completion of either source
1285 >     * thenRun result completes exceptionally after exceptional
1286 >     * completion of source
1287       */
1288 <    public void testAcceptEither2() {
1289 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1290 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1291 <        IncAction r = new IncAction();
1292 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1293 <        f.completeExceptionally(new CFException());
1294 <        f2.complete(one);
1295 <        checkCompletedWithWrappedCFException(g);
1288 >    public void testThenRun_exceptionalCompletion() {
1289 >        for (ExecutionMode m : ExecutionMode.values())
1290 >        for (boolean createIncomplete : new boolean[] { true, false })
1291 >    {
1292 >        final CFException ex = new CFException();
1293 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1294 >        final Noop r = new Noop(m);
1295 >        if (!createIncomplete) f.completeExceptionally(ex);
1296 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1297 >        if (createIncomplete) {
1298 >            checkIncomplete(g);
1299 >            f.completeExceptionally(ex);
1300 >        }
1301  
1302 <        r = new IncAction();
1303 <        f = new CompletableFuture<>();
1304 <        f2 = new CompletableFuture<>();
1305 <        f2.completeExceptionally(new CFException());
1388 <        g = f.acceptEither(f2, r);
1389 <        checkCompletedWithWrappedCFException(g);
1390 <    }
1302 >        checkCompletedWithWrappedException(g, ex);
1303 >        checkCompletedExceptionally(f, ex);
1304 >        r.assertNotInvoked();
1305 >    }}
1306  
1307      /**
1308 <     * acceptEither result completes exceptionally if action does
1308 >     * thenRun result completes exceptionally if source cancelled
1309       */
1310 <    public void testAcceptEither3() {
1311 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1312 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1313 <        FailingConsumer r = new FailingConsumer();
1314 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
1315 <        f2.complete(two);
1316 <        checkCompletedWithWrappedCFException(g);
1317 <    }
1310 >    public void testThenRun_sourceCancelled() {
1311 >        for (ExecutionMode m : ExecutionMode.values())
1312 >        for (boolean createIncomplete : new boolean[] { true, false })
1313 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1314 >    {
1315 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1316 >        final Noop r = new Noop(m);
1317 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1318 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1319 >        if (createIncomplete) {
1320 >            checkIncomplete(g);
1321 >            assertTrue(f.cancel(mayInterruptIfRunning));
1322 >        }
1323  
1404    /**
1405     * acceptEither result completes exceptionally if either source cancelled
1406     */
1407    public void testAcceptEither4() {
1408        CompletableFuture<Integer> f = new CompletableFuture<>();
1409        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1410        IncAction r = new IncAction();
1411        CompletableFuture<Void> g = f.acceptEither(f2, r);
1412        assertTrue(f.cancel(true));
1324          checkCompletedWithWrappedCancellationException(g);
1325 <        f = new CompletableFuture<>();
1326 <        f2 = new CompletableFuture<>();
1327 <        assertTrue(f2.cancel(true));
1417 <        checkCompletedWithWrappedCancellationException(g);
1418 <    }
1419 <
1420 <    /**
1421 <     * runAfterEither result completes normally after normal completion
1422 <     * of either source
1423 <     */
1424 <    public void testRunAfterEither() {
1425 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1426 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1427 <        Noop r = new Noop();
1428 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1429 <        f.complete(one);
1430 <        checkCompletedNormally(g, null);
1431 <        f2.complete(one);
1432 <        checkCompletedNormally(g, null);
1433 <        assertTrue(r.ran);
1434 <
1435 <        r = new Noop();
1436 <        f = new CompletableFuture<>();
1437 <        f.complete(one);
1438 <        f2 = new CompletableFuture<>();
1439 <        g = f.runAfterEither(f2, r);
1440 <        checkCompletedNormally(g, null);
1441 <        assertTrue(r.ran);
1442 <    }
1325 >        checkCancelled(f);
1326 >        r.assertNotInvoked();
1327 >    }}
1328  
1329      /**
1330 <     * runAfterEither result completes exceptionally after exceptional
1446 <     * completion of either source
1330 >     * thenRun result completes exceptionally if action does
1331       */
1332 <    public void testRunAfterEither2() {
1333 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1334 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1335 <        Noop r = new Noop();
1336 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1337 <        f.completeExceptionally(new CFException());
1338 <        f2.complete(one);
1339 <        checkCompletedWithWrappedCFException(g);
1340 <
1341 <        r = new Noop();
1342 <        f = new CompletableFuture<>();
1343 <        f2 = new CompletableFuture<>();
1344 <        f2.completeExceptionally(new CFException());
1461 <        g = f.runAfterEither(f2, r);
1462 <        checkCompletedWithWrappedCFException(g);
1463 <    }
1332 >    public void testThenRun_actionFailed() {
1333 >        for (ExecutionMode m : ExecutionMode.values())
1334 >        for (boolean createIncomplete : new boolean[] { true, false })
1335 >        for (Integer v1 : new Integer[] { 1, null })
1336 >    {
1337 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1338 >        final FailingRunnable r = new FailingRunnable(m);
1339 >        if (!createIncomplete) assertTrue(f.complete(v1));
1340 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1341 >        if (createIncomplete) {
1342 >            checkIncomplete(g);
1343 >            assertTrue(f.complete(v1));
1344 >        }
1345  
1465    /**
1466     * runAfterEither result completes exceptionally if action does
1467     */
1468    public void testRunAfterEither3() {
1469        CompletableFuture<Integer> f = new CompletableFuture<>();
1470        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1471        FailingNoop r = new FailingNoop();
1472        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1473        f2.complete(two);
1346          checkCompletedWithWrappedCFException(g);
1347 <    }
1348 <
1477 <    /**
1478 <     * runAfterEither result completes exceptionally if either source cancelled
1479 <     */
1480 <    public void testRunAfterEither4() {
1481 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1482 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1483 <        Noop r = new Noop();
1484 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1485 <        assertTrue(f.cancel(true));
1486 <        checkCompletedWithWrappedCancellationException(g);
1487 <        f = new CompletableFuture<>();
1488 <        f2 = new CompletableFuture<>();
1489 <        assertTrue(f2.cancel(true));
1490 <        checkCompletedWithWrappedCancellationException(g);
1491 <    }
1347 >        checkCompletedNormally(f, v1);
1348 >    }}
1349  
1350      /**
1351 <     * thenCompose result completes normally after normal completion of source
1351 >     * thenApply result completes normally after normal completion of source
1352       */
1353 <    public void testThenCompose() {
1354 <        CompletableFuture<Integer> f, g;
1355 <        CompletableFutureInc r;
1356 <
1357 <        f = new CompletableFuture<>();
1358 <        g = f.thenCompose(r = new CompletableFutureInc());
1359 <        f.complete(one);
1360 <        checkCompletedNormally(g, two);
1361 <        assertTrue(r.ran);
1353 >    public void testThenApply_normalCompletion() {
1354 >        for (ExecutionMode m : ExecutionMode.values())
1355 >        for (boolean createIncomplete : new boolean[] { true, false })
1356 >        for (Integer v1 : new Integer[] { 1, null })
1357 >    {
1358 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1359 >        final IncFunction r = new IncFunction(m);
1360 >        if (!createIncomplete) assertTrue(f.complete(v1));
1361 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1362 >        if (createIncomplete) {
1363 >            checkIncomplete(g);
1364 >            assertTrue(f.complete(v1));
1365 >        }
1366  
1367 <        f = new CompletableFuture<>();
1368 <        f.complete(one);
1369 <        g = f.thenCompose(r = new CompletableFutureInc());
1370 <        checkCompletedNormally(g, two);
1510 <        assertTrue(r.ran);
1511 <    }
1367 >        checkCompletedNormally(g, inc(v1));
1368 >        checkCompletedNormally(f, v1);
1369 >        r.assertValue(inc(v1));
1370 >    }}
1371  
1372      /**
1373 <     * thenCompose result completes exceptionally after exceptional
1373 >     * thenApply result completes exceptionally after exceptional
1374       * completion of source
1375       */
1376 <    public void testThenCompose2() {
1377 <        CompletableFuture<Integer> f, g;
1378 <        CompletableFutureInc r;
1379 <
1380 <        f = new CompletableFuture<>();
1381 <        g = f.thenCompose(r = new CompletableFutureInc());
1382 <        f.completeExceptionally(new CFException());
1383 <        checkCompletedWithWrappedCFException(g);
1384 <
1385 <        f = new CompletableFuture<>();
1386 <        f.completeExceptionally(new CFException());
1387 <        g = f.thenCompose(r = new CompletableFutureInc());
1388 <        checkCompletedWithWrappedCFException(g);
1530 <    }
1531 <
1532 <    /**
1533 <     * thenCompose result completes exceptionally if action does
1534 <     */
1535 <    public void testThenCompose3() {
1536 <        CompletableFuture<Integer> f, g;
1537 <        FailingCompletableFutureFunction r;
1538 <
1539 <        f = new CompletableFuture<>();
1540 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
1541 <        f.complete(one);
1542 <        checkCompletedWithWrappedCFException(g);
1376 >    public void testThenApply_exceptionalCompletion() {
1377 >        for (ExecutionMode m : ExecutionMode.values())
1378 >        for (boolean createIncomplete : new boolean[] { true, false })
1379 >    {
1380 >        final CFException ex = new CFException();
1381 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1382 >        final IncFunction r = new IncFunction(m);
1383 >        if (!createIncomplete) f.completeExceptionally(ex);
1384 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1385 >        if (createIncomplete) {
1386 >            checkIncomplete(g);
1387 >            f.completeExceptionally(ex);
1388 >        }
1389  
1390 <        f = new CompletableFuture<>();
1391 <        f.complete(one);
1392 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
1393 <        checkCompletedWithWrappedCFException(g);
1548 <    }
1390 >        checkCompletedWithWrappedException(g, ex);
1391 >        checkCompletedExceptionally(f, ex);
1392 >        r.assertNotInvoked();
1393 >    }}
1394  
1395      /**
1396 <     * thenCompose result completes exceptionally if source cancelled
1396 >     * thenApply result completes exceptionally if source cancelled
1397       */
1398 <    public void testThenCompose4() {
1399 <        CompletableFuture<Integer> f, g;
1400 <        CompletableFutureInc r;
1401 <
1402 <        f = new CompletableFuture<>();
1403 <        g = f.thenCompose(r = new CompletableFutureInc());
1404 <        assertTrue(f.cancel(true));
1405 <        checkCompletedWithWrappedCancellationException(g);
1398 >    public void testThenApply_sourceCancelled() {
1399 >        for (ExecutionMode m : ExecutionMode.values())
1400 >        for (boolean createIncomplete : new boolean[] { true, false })
1401 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1402 >    {
1403 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1404 >        final IncFunction r = new IncFunction(m);
1405 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1406 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1407 >        if (createIncomplete) {
1408 >            checkIncomplete(g);
1409 >            assertTrue(f.cancel(mayInterruptIfRunning));
1410 >        }
1411  
1562        f = new CompletableFuture<>();
1563        assertTrue(f.cancel(true));
1564        g = f.thenCompose(r = new CompletableFutureInc());
1412          checkCompletedWithWrappedCancellationException(g);
1413 <    }
1414 <
1415 <    // asyncs
1569 <
1570 <    /**
1571 <     * thenRunAsync result completes normally after normal completion of source
1572 <     */
1573 <    public void testThenRunAsync() {
1574 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1575 <        Noop r = new Noop();
1576 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1577 <        f.complete(null);
1578 <        checkCompletedNormally(g, null);
1579 <
1580 <        // reordered version
1581 <        f = new CompletableFuture<>();
1582 <        f.complete(null);
1583 <        r = new Noop();
1584 <        g = f.thenRunAsync(r);
1585 <        checkCompletedNormally(g, null);
1586 <    }
1413 >        checkCancelled(f);
1414 >        r.assertNotInvoked();
1415 >    }}
1416  
1417      /**
1418 <     * thenRunAsync result completes exceptionally after exceptional
1590 <     * completion of source
1418 >     * thenApply result completes exceptionally if action does
1419       */
1420 <    public void testThenRunAsync2() {
1421 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1422 <        Noop r = new Noop();
1423 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1424 <        f.completeExceptionally(new CFException());
1425 <        try {
1426 <            g.join();
1427 <            shouldThrow();
1428 <        } catch (CompletionException success) {}
1429 <        checkCompletedWithWrappedCFException(g);
1430 <    }
1420 >    public void testThenApply_actionFailed() {
1421 >        for (ExecutionMode m : ExecutionMode.values())
1422 >        for (boolean createIncomplete : new boolean[] { true, false })
1423 >        for (Integer v1 : new Integer[] { 1, null })
1424 >    {
1425 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1426 >        final FailingFunction r = new FailingFunction(m);
1427 >        if (!createIncomplete) assertTrue(f.complete(v1));
1428 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1429 >        if (createIncomplete) {
1430 >            checkIncomplete(g);
1431 >            assertTrue(f.complete(v1));
1432 >        }
1433  
1604    /**
1605     * thenRunAsync result completes exceptionally if action does
1606     */
1607    public void testThenRunAsync3() {
1608        CompletableFuture<Integer> f = new CompletableFuture<>();
1609        FailingNoop r = new FailingNoop();
1610        CompletableFuture<Void> g = f.thenRunAsync(r);
1611        f.complete(null);
1434          checkCompletedWithWrappedCFException(g);
1435 <    }
1435 >        checkCompletedNormally(f, v1);
1436 >    }}
1437  
1438      /**
1439 <     * thenRunAsync result completes exceptionally if source cancelled
1439 >     * thenAccept result completes normally after normal completion of source
1440       */
1441 <    public void testThenRunAsync4() {
1442 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1443 <        Noop r = new Noop();
1444 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1445 <        assertTrue(f.cancel(true));
1446 <        checkCompletedWithWrappedCancellationException(g);
1447 <    }
1441 >    public void testThenAccept_normalCompletion() {
1442 >        for (ExecutionMode m : ExecutionMode.values())
1443 >        for (boolean createIncomplete : new boolean[] { true, false })
1444 >        for (Integer v1 : new Integer[] { 1, null })
1445 >    {
1446 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1447 >        final NoopConsumer r = new NoopConsumer(m);
1448 >        if (!createIncomplete) assertTrue(f.complete(v1));
1449 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1450 >        if (createIncomplete) {
1451 >            checkIncomplete(g);
1452 >            assertTrue(f.complete(v1));
1453 >        }
1454  
1455 <    /**
1456 <     * thenApplyAsync result completes normally after normal completion of source
1457 <     */
1458 <    public void testThenApplyAsync() {
1630 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1631 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
1632 <        f.complete(one);
1633 <        checkCompletedNormally(g, two);
1634 <    }
1455 >        checkCompletedNormally(g, null);
1456 >        r.assertValue(v1);
1457 >        checkCompletedNormally(f, v1);
1458 >    }}
1459  
1460      /**
1461 <     * thenApplyAsync result completes exceptionally after exceptional
1461 >     * thenAccept result completes exceptionally after exceptional
1462       * completion of source
1463       */
1464 <    public void testThenApplyAsync2() {
1465 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1466 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
1467 <        f.completeExceptionally(new CFException());
1468 <        checkCompletedWithWrappedCFException(g);
1469 <    }
1464 >    public void testThenAccept_exceptionalCompletion() {
1465 >        for (ExecutionMode m : ExecutionMode.values())
1466 >        for (boolean createIncomplete : new boolean[] { true, false })
1467 >    {
1468 >        final CFException ex = new CFException();
1469 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1470 >        final NoopConsumer r = new NoopConsumer(m);
1471 >        if (!createIncomplete) f.completeExceptionally(ex);
1472 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1473 >        if (createIncomplete) {
1474 >            checkIncomplete(g);
1475 >            f.completeExceptionally(ex);
1476 >        }
1477  
1478 <    /**
1479 <     * thenApplyAsync result completes exceptionally if action does
1480 <     */
1481 <    public void testThenApplyAsync3() {
1651 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1652 <        FailingFunction r = new FailingFunction();
1653 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
1654 <        f.complete(null);
1655 <        checkCompletedWithWrappedCFException(g);
1656 <    }
1478 >        checkCompletedWithWrappedException(g, ex);
1479 >        checkCompletedExceptionally(f, ex);
1480 >        r.assertNotInvoked();
1481 >    }}
1482  
1483      /**
1484 <     * thenApplyAsync result completes exceptionally if source cancelled
1484 >     * thenAccept result completes exceptionally if source cancelled
1485       */
1486 <    public void testThenApplyAsync4() {
1487 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1488 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
1489 <        assertTrue(f.cancel(true));
1490 <        checkCompletedWithWrappedCancellationException(g);
1491 <    }
1486 >    public void testThenAccept_sourceCancelled() {
1487 >        for (ExecutionMode m : ExecutionMode.values())
1488 >        for (boolean createIncomplete : new boolean[] { true, false })
1489 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1490 >    {
1491 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1492 >        final NoopConsumer r = new NoopConsumer(m);
1493 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1494 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1495 >        if (createIncomplete) {
1496 >            checkIncomplete(g);
1497 >            assertTrue(f.cancel(mayInterruptIfRunning));
1498 >        }
1499  
1500 <    /**
1501 <     * thenAcceptAsync result completes normally after normal
1502 <     * completion of source
1503 <     */
1672 <    public void testThenAcceptAsync() {
1673 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1674 <        IncAction r = new IncAction();
1675 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1676 <        f.complete(one);
1677 <        checkCompletedNormally(g, null);
1678 <        assertEquals(r.value, 2);
1679 <    }
1500 >        checkCompletedWithWrappedCancellationException(g);
1501 >        checkCancelled(f);
1502 >        r.assertNotInvoked();
1503 >    }}
1504  
1505      /**
1506 <     * thenAcceptAsync result completes exceptionally after exceptional
1683 <     * completion of source
1506 >     * thenAccept result completes exceptionally if action does
1507       */
1508 <    public void testThenAcceptAsync2() {
1509 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1510 <        IncAction r = new IncAction();
1511 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1512 <        f.completeExceptionally(new CFException());
1513 <        checkCompletedWithWrappedCFException(g);
1514 <    }
1508 >    public void testThenAccept_actionFailed() {
1509 >        for (ExecutionMode m : ExecutionMode.values())
1510 >        for (boolean createIncomplete : new boolean[] { true, false })
1511 >        for (Integer v1 : new Integer[] { 1, null })
1512 >    {
1513 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1514 >        final FailingConsumer r = new FailingConsumer(m);
1515 >        if (!createIncomplete) f.complete(v1);
1516 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1517 >        if (createIncomplete) {
1518 >            checkIncomplete(g);
1519 >            f.complete(v1);
1520 >        }
1521  
1693    /**
1694     * thenAcceptAsync result completes exceptionally if action does
1695     */
1696    public void testThenAcceptAsync3() {
1697        CompletableFuture<Integer> f = new CompletableFuture<>();
1698        FailingConsumer r = new FailingConsumer();
1699        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1700        f.complete(null);
1522          checkCompletedWithWrappedCFException(g);
1523 <    }
1524 <
1704 <    /**
1705 <     * thenAcceptAsync result completes exceptionally if source cancelled
1706 <     */
1707 <    public void testThenAcceptAsync4() {
1708 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1709 <        IncAction r = new IncAction();
1710 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1711 <        assertTrue(f.cancel(true));
1712 <        checkCompletedWithWrappedCancellationException(g);
1713 <    }
1523 >        checkCompletedNormally(f, v1);
1524 >    }}
1525  
1526      /**
1527 <     * thenCombineAsync result completes normally after normal
1528 <     * completion of sources
1527 >     * thenCombine result completes normally after normal completion
1528 >     * of sources
1529       */
1530 <    public void testThenCombineAsync() {
1531 <        CompletableFuture<Integer> f, g, h;
1532 <
1533 <        f = new CompletableFuture<>();
1534 <        g = new CompletableFuture<>();
1535 <        h = f.thenCombineAsync(g, subtract);
1536 <        f.complete(3);
1537 <        checkIncomplete(h);
1538 <        g.complete(1);
1539 <        checkCompletedNormally(h, 2);
1530 >    public void testThenCombine_normalCompletion() {
1531 >        for (ExecutionMode m : ExecutionMode.values())
1532 >        for (boolean createIncomplete : new boolean[] { true, false })
1533 >        for (boolean fFirst : new boolean[] { true, false })
1534 >        for (Integer v1 : new Integer[] { 1, null })
1535 >        for (Integer v2 : new Integer[] { 2, null })
1536 >    {
1537 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1538 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1539 >        final SubtractFunction r = new SubtractFunction(m);
1540  
1541 <        f = new CompletableFuture<>();
1542 <        g = new CompletableFuture<>();
1543 <        h = f.thenCombineAsync(g, subtract);
1544 <        g.complete(1);
1545 <        checkIncomplete(h);
1546 <        f.complete(3);
1547 <        checkCompletedNormally(h, 2);
1541 >        assertTrue(fFirst ? f.complete(v1) : g.complete(v2));
1542 >        if (!createIncomplete)
1543 >            assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1544 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1545 >        if (createIncomplete) {
1546 >            checkIncomplete(h);
1547 >            r.assertNotInvoked();
1548 >            assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1549 >        }
1550  
1551 <        f = new CompletableFuture<>();
1552 <        g = new CompletableFuture<>();
1553 <        g.complete(1);
1554 <        f.complete(3);
1555 <        h = f.thenCombineAsync(g, subtract);
1743 <        checkCompletedNormally(h, 2);
1744 <    }
1551 >        checkCompletedNormally(h, subtract(v1, v2));
1552 >        checkCompletedNormally(f, v1);
1553 >        checkCompletedNormally(g, v2);
1554 >        r.assertValue(subtract(v1, v2));
1555 >    }}
1556  
1557      /**
1558 <     * thenCombineAsync result completes exceptionally after exceptional
1558 >     * thenCombine result completes exceptionally after exceptional
1559       * completion of either source
1560       */
1561 <    public void testThenCombineAsync2() {
1562 <        CompletableFuture<Integer> f, g, h;
1563 <
1564 <        f = new CompletableFuture<>();
1565 <        g = new CompletableFuture<>();
1566 <        h = f.thenCombineAsync(g, subtract);
1567 <        f.completeExceptionally(new CFException());
1568 <        checkIncomplete(h);
1569 <        g.complete(1);
1570 <        checkCompletedWithWrappedCFException(h);
1760 <
1761 <        f = new CompletableFuture<>();
1762 <        g = new CompletableFuture<>();
1763 <        h = f.thenCombineAsync(g, subtract);
1764 <        g.completeExceptionally(new CFException());
1765 <        checkIncomplete(h);
1766 <        f.complete(3);
1767 <        checkCompletedWithWrappedCFException(h);
1768 <
1769 <        f = new CompletableFuture<>();
1770 <        g = new CompletableFuture<>();
1771 <        g.completeExceptionally(new CFException());
1772 <        f.complete(3);
1773 <        h = f.thenCombineAsync(g, subtract);
1774 <        checkCompletedWithWrappedCFException(h);
1775 <    }
1561 >    public void testThenCombine_exceptionalCompletion() {
1562 >        for (ExecutionMode m : ExecutionMode.values())
1563 >        for (boolean createIncomplete : new boolean[] { true, false })
1564 >        for (boolean fFirst : new boolean[] { true, false })
1565 >        for (Integer v1 : new Integer[] { 1, null })
1566 >    {
1567 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1568 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1569 >        final CFException ex = new CFException();
1570 >        final SubtractFunction r = new SubtractFunction(m);
1571  
1572 <    /**
1573 <     * thenCombineAsync result completes exceptionally if action does
1574 <     */
1575 <    public void testThenCombineAsync3() {
1576 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1577 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1578 <        FailingBiFunction r = new FailingBiFunction();
1579 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1580 <        f.complete(one);
1581 <        checkIncomplete(g);
1582 <        assertFalse(r.ran);
1583 <        f2.complete(two);
1584 <        checkCompletedWithWrappedCFException(g);
1585 <        assertTrue(r.ran);
1791 <    }
1572 >        assertTrue((fFirst ? f : g).complete(v1));
1573 >        if (!createIncomplete)
1574 >            assertTrue((!fFirst ? f : g).completeExceptionally(ex));
1575 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1576 >        if (createIncomplete) {
1577 >            checkIncomplete(h);
1578 >            assertTrue((!fFirst ? f : g).completeExceptionally(ex));
1579 >        }
1580 >
1581 >        checkCompletedWithWrappedException(h, ex);
1582 >        r.assertNotInvoked();
1583 >        checkCompletedNormally(fFirst ? f : g, v1);
1584 >        checkCompletedExceptionally(!fFirst ? f : g, ex);
1585 >    }}
1586  
1587      /**
1588 <     * thenCombineAsync result completes exceptionally if either source cancelled
1588 >     * thenCombine result completes exceptionally if either source cancelled
1589       */
1590 <    public void testThenCombineAsync4() {
1591 <        CompletableFuture<Integer> f, g, h;
1592 <
1593 <        f = new CompletableFuture<>();
1594 <        g = new CompletableFuture<>();
1595 <        h = f.thenCombineAsync(g, subtract);
1596 <        assertTrue(f.cancel(true));
1597 <        checkIncomplete(h);
1598 <        g.complete(1);
1599 <        checkCompletedWithWrappedCancellationException(h);
1806 <
1807 <        f = new CompletableFuture<>();
1808 <        g = new CompletableFuture<>();
1809 <        h = f.thenCombineAsync(g, subtract);
1810 <        assertTrue(g.cancel(true));
1811 <        checkIncomplete(h);
1812 <        f.complete(3);
1813 <        checkCompletedWithWrappedCancellationException(h);
1590 >    public void testThenCombine_sourceCancelled() {
1591 >        for (ExecutionMode m : ExecutionMode.values())
1592 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1593 >        for (boolean createIncomplete : new boolean[] { true, false })
1594 >        for (boolean fFirst : new boolean[] { true, false })
1595 >        for (Integer v1 : new Integer[] { 1, null })
1596 >    {
1597 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1598 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1599 >        final SubtractFunction r = new SubtractFunction(m);
1600  
1601 <        f = new CompletableFuture<>();
1602 <        g = new CompletableFuture<>();
1603 <        g.complete(3);
1604 <        assertTrue(f.cancel(true));
1605 <        h = f.thenCombineAsync(g, subtract);
1606 <        checkCompletedWithWrappedCancellationException(h);
1601 >        assertTrue((fFirst ? f : g).complete(v1));
1602 >        if (!createIncomplete)
1603 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1604 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1605 >        if (createIncomplete) {
1606 >            checkIncomplete(h);
1607 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1608 >        }
1609  
1822        f = new CompletableFuture<>();
1823        g = new CompletableFuture<>();
1824        f.complete(3);
1825        assertTrue(g.cancel(true));
1826        h = f.thenCombineAsync(g, subtract);
1610          checkCompletedWithWrappedCancellationException(h);
1611 <    }
1611 >        checkCancelled(!fFirst ? f : g);
1612 >        r.assertNotInvoked();
1613 >        checkCompletedNormally(fFirst ? f : g, v1);
1614 >    }}
1615  
1616      /**
1617 <     * thenAcceptBothAsync result completes normally after normal
1832 <     * completion of sources
1833 <     */
1834 <    public void testThenAcceptBothAsync() {
1835 <        CompletableFuture<Integer> f, g;
1836 <        CompletableFuture<Void> h;
1837 <        SubtractAction r;
1838 <
1839 <        f = new CompletableFuture<>();
1840 <        g = new CompletableFuture<>();
1841 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1842 <        f.complete(3);
1843 <        checkIncomplete(h);
1844 <        g.complete(1);
1845 <        checkCompletedNormally(h, null);
1846 <        assertEquals(r.value, 2);
1847 <
1848 <        f = new CompletableFuture<>();
1849 <        g = new CompletableFuture<>();
1850 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1851 <        g.complete(1);
1852 <        checkIncomplete(h);
1853 <        f.complete(3);
1854 <        checkCompletedNormally(h, null);
1855 <        assertEquals(r.value, 2);
1856 <
1857 <        f = new CompletableFuture<>();
1858 <        g = new CompletableFuture<>();
1859 <        g.complete(1);
1860 <        f.complete(3);
1861 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1862 <        checkCompletedNormally(h, null);
1863 <        assertEquals(r.value, 2);
1864 <    }
1865 <
1866 <    /**
1867 <     * thenAcceptBothAsync result completes exceptionally after exceptional
1868 <     * completion of source
1617 >     * thenCombine result completes exceptionally if action does
1618       */
1619 <    public void testThenAcceptBothAsync2() {
1620 <        CompletableFuture<Integer> f, g;
1621 <        CompletableFuture<Void> h;
1622 <        SubtractAction r;
1623 <
1624 <        f = new CompletableFuture<>();
1625 <        g = new CompletableFuture<>();
1626 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1627 <        f.completeExceptionally(new CFException());
1628 <        checkIncomplete(h);
1880 <        g.complete(1);
1881 <        checkCompletedWithWrappedCFException(h);
1619 >    public void testThenCombine_actionFailed() {
1620 >        for (ExecutionMode m : ExecutionMode.values())
1621 >        for (boolean fFirst : new boolean[] { true, false })
1622 >        for (Integer v1 : new Integer[] { 1, null })
1623 >        for (Integer v2 : new Integer[] { 2, null })
1624 >    {
1625 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1626 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1627 >        final FailingBiFunction r = new FailingBiFunction(m);
1628 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1629  
1630 <        f = new CompletableFuture<>();
1631 <        g = new CompletableFuture<>();
1885 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1886 <        g.completeExceptionally(new CFException());
1887 <        checkIncomplete(h);
1888 <        f.complete(3);
1889 <        checkCompletedWithWrappedCFException(h);
1630 >        assertTrue( fFirst ? f.complete(v1) : g.complete(v2));
1631 >        assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1632  
1891        f = new CompletableFuture<>();
1892        g = new CompletableFuture<>();
1893        f.complete(3);
1894        g.completeExceptionally(new CFException());
1895        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1633          checkCompletedWithWrappedCFException(h);
1634 <
1635 <        f = new CompletableFuture<>();
1636 <        g = new CompletableFuture<>();
1900 <        f.completeExceptionally(new CFException());
1901 <        g.complete(3);
1902 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1903 <        checkCompletedWithWrappedCFException(h);
1904 <    }
1634 >        checkCompletedNormally(f, v1);
1635 >        checkCompletedNormally(g, v2);
1636 >    }}
1637  
1638      /**
1639 <     * thenAcceptBothAsync result completes exceptionally if action does
1639 >     * thenAcceptBoth result completes normally after normal
1640 >     * completion of sources
1641       */
1642 <    public void testThenAcceptBothAsync3() {
1643 <        CompletableFuture<Integer> f, g;
1644 <        CompletableFuture<Void> h;
1645 <        FailingBiConsumer r;
1642 >    public void testThenAcceptBoth_normalCompletion() {
1643 >        for (ExecutionMode m : ExecutionMode.values())
1644 >        for (boolean createIncomplete : new boolean[] { true, false })
1645 >        for (boolean fFirst : new boolean[] { true, false })
1646 >        for (Integer v1 : new Integer[] { 1, null })
1647 >        for (Integer v2 : new Integer[] { 2, null })
1648 >    {
1649 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1650 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1651 >        final SubtractAction r = new SubtractAction(m);
1652  
1653 <        f = new CompletableFuture<>();
1654 <        g = new CompletableFuture<>();
1655 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1656 <        f.complete(3);
1657 <        checkIncomplete(h);
1658 <        g.complete(1);
1659 <        checkCompletedWithWrappedCFException(h);
1653 >        assertTrue(fFirst ? f.complete(v1) : g.complete(v2));
1654 >        if (!createIncomplete)
1655 >            assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1656 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1657 >        if (createIncomplete) {
1658 >            checkIncomplete(h);
1659 >            r.assertNotInvoked();
1660 >            assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1661 >        }
1662  
1663 <        f = new CompletableFuture<>();
1664 <        g = new CompletableFuture<>();
1665 <        f.complete(3);
1666 <        g.complete(1);
1667 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1927 <        checkCompletedWithWrappedCFException(h);
1928 <    }
1663 >        checkCompletedNormally(h, null);
1664 >        r.assertValue(subtract(v1, v2));
1665 >        checkCompletedNormally(f, v1);
1666 >        checkCompletedNormally(g, v2);
1667 >    }}
1668  
1669      /**
1670 <     * thenAcceptBothAsync result completes exceptionally if either source cancelled
1670 >     * thenAcceptBoth result completes exceptionally after exceptional
1671 >     * completion of either source
1672       */
1673 <    public void testThenAcceptBothAsync4() {
1674 <        CompletableFuture<Integer> f, g;
1675 <        CompletableFuture<Void> h;
1676 <        SubtractAction r;
1677 <
1678 <        f = new CompletableFuture<>();
1679 <        g = new CompletableFuture<>();
1680 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1681 <        assertTrue(f.cancel(true));
1682 <        checkIncomplete(h);
1943 <        g.complete(1);
1944 <        checkCompletedWithWrappedCancellationException(h);
1945 <
1946 <        f = new CompletableFuture<>();
1947 <        g = new CompletableFuture<>();
1948 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1949 <        assertTrue(g.cancel(true));
1950 <        checkIncomplete(h);
1951 <        f.complete(3);
1952 <        checkCompletedWithWrappedCancellationException(h);
1953 <
1954 <        f = new CompletableFuture<>();
1955 <        g = new CompletableFuture<>();
1956 <        f.complete(3);
1957 <        assertTrue(g.cancel(true));
1958 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1959 <        checkCompletedWithWrappedCancellationException(h);
1673 >    public void testThenAcceptBoth_exceptionalCompletion() {
1674 >        for (ExecutionMode m : ExecutionMode.values())
1675 >        for (boolean createIncomplete : new boolean[] { true, false })
1676 >        for (boolean fFirst : new boolean[] { true, false })
1677 >        for (Integer v1 : new Integer[] { 1, null })
1678 >    {
1679 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1680 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1681 >        final CFException ex = new CFException();
1682 >        final SubtractAction r = new SubtractAction(m);
1683  
1684 <        f = new CompletableFuture<>();
1685 <        g = new CompletableFuture<>();
1686 <        assertTrue(f.cancel(true));
1687 <        g.complete(3);
1688 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1689 <        checkCompletedWithWrappedCancellationException(h);
1690 <    }
1684 >        assertTrue((fFirst ? f : g).complete(v1));
1685 >        if (!createIncomplete)
1686 >            assertTrue((!fFirst ? f : g).completeExceptionally(ex));
1687 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1688 >        if (createIncomplete) {
1689 >            checkIncomplete(h);
1690 >            assertTrue((!fFirst ? f : g).completeExceptionally(ex));
1691 >        }
1692 >
1693 >        checkCompletedWithWrappedException(h, ex);
1694 >        r.assertNotInvoked();
1695 >        checkCompletedNormally(fFirst ? f : g, v1);
1696 >        checkCompletedExceptionally(!fFirst ? f : g, ex);
1697 >    }}
1698  
1699      /**
1700 <     * applyToEitherAsync result completes normally after normal
1971 <     * completion of sources
1700 >     * thenAcceptBoth result completes exceptionally if either source cancelled
1701       */
1702 <    public void testApplyToEitherAsync() {
1703 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1704 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1705 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1706 <        f.complete(one);
1707 <        checkCompletedNormally(g, two);
1708 <
1709 <        f = new CompletableFuture<>();
1710 <        f.complete(one);
1711 <        f2 = new CompletableFuture<>();
1983 <        g = f.applyToEitherAsync(f2, inc);
1984 <        checkCompletedNormally(g, two);
1985 <    }
1702 >    public void testThenAcceptBoth_sourceCancelled() {
1703 >        for (ExecutionMode m : ExecutionMode.values())
1704 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1705 >        for (boolean createIncomplete : new boolean[] { true, false })
1706 >        for (boolean fFirst : new boolean[] { true, false })
1707 >        for (Integer v1 : new Integer[] { 1, null })
1708 >    {
1709 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1710 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1711 >        final SubtractAction r = new SubtractAction(m);
1712  
1713 <    /**
1714 <     * applyToEitherAsync result completes exceptionally after exceptional
1715 <     * completion of source
1716 <     */
1717 <    public void testApplyToEitherAsync2() {
1718 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1719 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1720 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1995 <        f.completeExceptionally(new CFException());
1996 <        checkCompletedWithWrappedCFException(g);
1713 >        assertTrue((fFirst ? f : g).complete(v1));
1714 >        if (!createIncomplete)
1715 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1716 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1717 >        if (createIncomplete) {
1718 >            checkIncomplete(h);
1719 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1720 >        }
1721  
1722 <        f = new CompletableFuture<>();
1723 <        f2 = new CompletableFuture<>();
1724 <        f2.completeExceptionally(new CFException());
1725 <        g = f.applyToEitherAsync(f2, inc);
1726 <        f.complete(one);
2003 <        checkCompletedWithWrappedCFException(g);
2004 <    }
1722 >        checkCompletedWithWrappedCancellationException(h);
1723 >        checkCancelled(!fFirst ? f : g);
1724 >        r.assertNotInvoked();
1725 >        checkCompletedNormally(fFirst ? f : g, v1);
1726 >    }}
1727  
1728      /**
1729 <     * applyToEitherAsync result completes exceptionally if action does
1729 >     * thenAcceptBoth result completes exceptionally if action does
1730       */
1731 <    public void testApplyToEitherAsync3() {
1732 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1733 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1734 <        FailingFunction r = new FailingFunction();
1735 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
1736 <        f.complete(one);
1737 <        checkCompletedWithWrappedCFException(g);
1738 <    }
1731 >    public void testThenAcceptBoth_actionFailed() {
1732 >        for (ExecutionMode m : ExecutionMode.values())
1733 >        for (boolean fFirst : new boolean[] { true, false })
1734 >        for (Integer v1 : new Integer[] { 1, null })
1735 >        for (Integer v2 : new Integer[] { 2, null })
1736 >    {
1737 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1738 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1739 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1740 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1741  
1742 <    /**
1743 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2020 <     */
2021 <    public void testApplyToEitherAsync4() {
2022 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2023 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2024 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2025 <        assertTrue(f.cancel(true));
2026 <        checkCompletedWithWrappedCancellationException(g);
1742 >        assertTrue(fFirst ? f.complete(v1) : g.complete(v2));
1743 >        assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1744  
1745 <        f = new CompletableFuture<>();
1746 <        f2 = new CompletableFuture<>();
1747 <        assertTrue(f2.cancel(true));
1748 <        g = f.applyToEitherAsync(f2, inc);
2032 <        checkCompletedWithWrappedCancellationException(g);
2033 <    }
1745 >        checkCompletedWithWrappedCFException(h);
1746 >        checkCompletedNormally(f, v1);
1747 >        checkCompletedNormally(g, v2);
1748 >    }}
1749  
1750      /**
1751 <     * acceptEitherAsync result completes normally after normal
1751 >     * runAfterBoth result completes normally after normal
1752       * completion of sources
1753       */
1754 <    public void testAcceptEitherAsync() {
1755 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1756 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1757 <        IncAction r = new IncAction();
1758 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1759 <        f.complete(one);
1760 <        checkCompletedNormally(g, null);
1761 <        assertEquals(r.value, 2);
1762 <
1763 <        r = new IncAction();
2049 <        f = new CompletableFuture<>();
2050 <        f.complete(one);
2051 <        f2 = new CompletableFuture<>();
2052 <        g = f.acceptEitherAsync(f2, r);
2053 <        checkCompletedNormally(g, null);
2054 <        assertEquals(r.value, 2);
2055 <    }
1754 >    public void testRunAfterBoth_normalCompletion() {
1755 >        for (ExecutionMode m : ExecutionMode.values())
1756 >        for (boolean createIncomplete : new boolean[] { true, false })
1757 >        for (boolean fFirst : new boolean[] { true, false })
1758 >        for (Integer v1 : new Integer[] { 1, null })
1759 >        for (Integer v2 : new Integer[] { 2, null })
1760 >    {
1761 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1762 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1763 >        final Noop r = new Noop(m);
1764  
1765 <    /**
1766 <     * acceptEitherAsync result completes exceptionally after exceptional
1767 <     * completion of source
1768 <     */
1769 <    public void testAcceptEitherAsync2() {
1770 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1771 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1772 <        IncAction r = new IncAction();
1773 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2066 <        f.completeExceptionally(new CFException());
2067 <        checkCompletedWithWrappedCFException(g);
1765 >        assertTrue(fFirst ? f.complete(v1) : g.complete(v2));
1766 >        if (!createIncomplete)
1767 >            assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1768 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1769 >        if (createIncomplete) {
1770 >            checkIncomplete(h);
1771 >            r.assertNotInvoked();
1772 >            assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1773 >        }
1774  
1775 <        r = new IncAction();
1776 <        f = new CompletableFuture<>();
1777 <        f2 = new CompletableFuture<>();
1778 <        f2.completeExceptionally(new CFException());
1779 <        g = f.acceptEitherAsync(f2, r);
2074 <        f.complete(one);
2075 <        checkCompletedWithWrappedCFException(g);
2076 <    }
1775 >        checkCompletedNormally(h, null);
1776 >        r.assertInvoked();
1777 >        checkCompletedNormally(f, v1);
1778 >        checkCompletedNormally(g, v2);
1779 >    }}
1780  
1781      /**
1782 <     * acceptEitherAsync result completes exceptionally if action does
1782 >     * runAfterBoth result completes exceptionally after exceptional
1783 >     * completion of either source
1784       */
1785 <    public void testAcceptEitherAsync3() {
1786 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1787 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1788 <        FailingConsumer r = new FailingConsumer();
1789 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1790 <        f.complete(one);
1791 <        checkCompletedWithWrappedCFException(g);
1792 <    }
1785 >    public void testRunAfterBoth_exceptionalCompletion() {
1786 >        for (ExecutionMode m : ExecutionMode.values())
1787 >        for (boolean createIncomplete : new boolean[] { true, false })
1788 >        for (boolean fFirst : new boolean[] { true, false })
1789 >        for (Integer v1 : new Integer[] { 1, null })
1790 >    {
1791 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1792 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1793 >        final CFException ex = new CFException();
1794 >        final Noop r = new Noop(m);
1795  
1796 <    /**
1797 <     * acceptEitherAsync result completes exceptionally if either
1798 <     * source cancelled
1799 <     */
1800 <    public void testAcceptEitherAsync4() {
1801 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1802 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1803 <        IncAction r = new IncAction();
2098 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2099 <        assertTrue(f.cancel(true));
2100 <        checkCompletedWithWrappedCancellationException(g);
1796 >        assertTrue((fFirst ? f : g).complete(v1));
1797 >        if (!createIncomplete)
1798 >            assertTrue((!fFirst ? f : g).completeExceptionally(ex));
1799 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1800 >        if (createIncomplete) {
1801 >            checkIncomplete(h);
1802 >            assertTrue((!fFirst ? f : g).completeExceptionally(ex));
1803 >        }
1804  
1805 <        r = new IncAction();
1806 <        f = new CompletableFuture<>();
1807 <        f2 = new CompletableFuture<>();
1808 <        assertTrue(f2.cancel(true));
1809 <        g = f.acceptEitherAsync(f2, r);
2107 <        checkCompletedWithWrappedCancellationException(g);
2108 <    }
1805 >        checkCompletedWithWrappedException(h, ex);
1806 >        r.assertNotInvoked();
1807 >        checkCompletedNormally(fFirst ? f : g, v1);
1808 >        checkCompletedExceptionally(!fFirst ? f : g, ex);
1809 >    }}
1810  
1811      /**
1812 <     * runAfterEitherAsync result completes normally after normal
2112 <     * completion of sources
1812 >     * runAfterBoth result completes exceptionally if either source cancelled
1813       */
1814 <    public void testRunAfterEitherAsync() {
1815 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1816 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1817 <        Noop r = new Noop();
1818 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1819 <        f.complete(one);
1820 <        checkCompletedNormally(g, null);
1821 <        assertTrue(r.ran);
1822 <
1823 <        r = new Noop();
2124 <        f = new CompletableFuture<>();
2125 <        f.complete(one);
2126 <        f2 = new CompletableFuture<>();
2127 <        g = f.runAfterEitherAsync(f2, r);
2128 <        checkCompletedNormally(g, null);
2129 <        assertTrue(r.ran);
2130 <    }
1814 >    public void testRunAfterBoth_sourceCancelled() {
1815 >        for (ExecutionMode m : ExecutionMode.values())
1816 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1817 >        for (boolean createIncomplete : new boolean[] { true, false })
1818 >        for (boolean fFirst : new boolean[] { true, false })
1819 >        for (Integer v1 : new Integer[] { 1, null })
1820 >    {
1821 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1822 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1823 >        final Noop r = new Noop(m);
1824  
1825 <    /**
1826 <     * runAfterEitherAsync result completes exceptionally after exceptional
1827 <     * completion of source
1828 <     */
1829 <    public void testRunAfterEitherAsync2() {
1830 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1831 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1832 <        Noop r = new Noop();
2140 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2141 <        f.completeExceptionally(new CFException());
2142 <        checkCompletedWithWrappedCFException(g);
1825 >        assertTrue((fFirst ? f : g).complete(v1));
1826 >        if (!createIncomplete)
1827 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1828 >        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1829 >        if (createIncomplete) {
1830 >            checkIncomplete(h);
1831 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1832 >        }
1833  
1834 <        r = new Noop();
1835 <        f = new CompletableFuture<>();
1836 <        f2 = new CompletableFuture<>();
1837 <        f2.completeExceptionally(new CFException());
1838 <        g = f.runAfterEitherAsync(f2, r);
2149 <        f.complete(one);
2150 <        checkCompletedWithWrappedCFException(g);
2151 <    }
1834 >        checkCompletedWithWrappedCancellationException(h);
1835 >        checkCancelled(!fFirst ? f : g);
1836 >        r.assertNotInvoked();
1837 >        checkCompletedNormally(fFirst ? f : g, v1);
1838 >    }}
1839  
1840      /**
1841 <     * runAfterEitherAsync result completes exceptionally if action does
1841 >     * runAfterBoth result completes exceptionally if action does
1842       */
1843 <    public void testRunAfterEitherAsync3() {
1844 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1845 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1846 <        FailingNoop r = new FailingNoop();
1847 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1848 <        f.complete(one);
1849 <        checkCompletedWithWrappedCFException(g);
1850 <    }
1843 >    public void testRunAfterBoth_actionFailed() {
1844 >        for (ExecutionMode m : ExecutionMode.values())
1845 >        for (boolean fFirst : new boolean[] { true, false })
1846 >        for (Integer v1 : new Integer[] { 1, null })
1847 >        for (Integer v2 : new Integer[] { 2, null })
1848 >    {
1849 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1850 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1851 >        final FailingRunnable r1 = new FailingRunnable(m);
1852 >        final FailingRunnable r2 = new FailingRunnable(m);
1853  
1854 <    /**
1855 <     * runAfterEitherAsync result completes exceptionally if either
1856 <     * source cancelled
1857 <     */
2169 <    public void testRunAfterEitherAsync4() {
2170 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2171 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2172 <        Noop r = new Noop();
2173 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2174 <        assertTrue(f.cancel(true));
2175 <        checkCompletedWithWrappedCancellationException(g);
1854 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1855 >        assertTrue(fFirst ? f.complete(v1) : g.complete(v2));
1856 >        assertTrue(!fFirst ? f.complete(v1) : g.complete(v2));
1857 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1858  
1859 <        r = new Noop();
1860 <        f = new CompletableFuture<>();
1861 <        f2 = new CompletableFuture<>();
1862 <        assertTrue(f2.cancel(true));
1863 <        g = f.runAfterEitherAsync(f2, r);
2182 <        checkCompletedWithWrappedCancellationException(g);
2183 <    }
1859 >        checkCompletedWithWrappedCFException(h1);
1860 >        checkCompletedWithWrappedCFException(h2);
1861 >        checkCompletedNormally(f, v1);
1862 >        checkCompletedNormally(g, v2);
1863 >    }}
1864  
1865      /**
1866 <     * thenComposeAsync result completes normally after normal
1867 <     * completion of source
1866 >     * applyToEither result completes normally after normal completion
1867 >     * of either source
1868       */
1869 <    public void testThenComposeAsync() {
1870 <        CompletableFuture<Integer> f, g;
1871 <        CompletableFutureInc r;
1872 <
1873 <        f = new CompletableFuture<>();
1874 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
1875 <        f.complete(one);
1876 <        checkCompletedNormally(g, two);
1877 <
2198 <        f = new CompletableFuture<>();
2199 <        f.complete(one);
2200 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2201 <        checkCompletedNormally(g, two);
2202 <    }
1869 >    public void testApplyToEither_normalCompletion() {
1870 >        for (ExecutionMode m : ExecutionMode.values())
1871 >        for (Integer v1 : new Integer[] { 1, null })
1872 >        for (Integer v2 : new Integer[] { 2, null })
1873 >    {
1874 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1875 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1876 >        final IncFunction[] rs = new IncFunction[6];
1877 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1878  
1879 <    /**
1880 <     * thenComposeAsync result completes exceptionally after
1881 <     * exceptional completion of source
1882 <     */
1883 <    public void testThenComposeAsync2() {
1884 <        CompletableFuture<Integer> f, g;
1885 <        CompletableFutureInc r;
1879 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1880 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1881 >        checkIncomplete(h0);
1882 >        checkIncomplete(h1);
1883 >        rs[0].assertNotInvoked();
1884 >        rs[1].assertNotInvoked();
1885 >        f.complete(v1);
1886 >        checkCompletedNormally(h0, inc(v1));
1887 >        checkCompletedNormally(h1, inc(v1));
1888 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1889 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1890 >        checkCompletedNormally(h2, inc(v1));
1891 >        checkCompletedNormally(h3, inc(v1));
1892 >        g.complete(v2);
1893  
1894 <        f = new CompletableFuture<>();
1895 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
1896 <        f.completeExceptionally(new CFException());
1897 <        checkCompletedWithWrappedCFException(g);
1898 <        assertFalse(r.ran);
1894 >        // unspecified behavior - both source completions available
1895 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1896 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1897 >        rs[4].assertValue(h4.join());
1898 >        rs[5].assertValue(h5.join());
1899 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
1900 >                   Objects.equals(inc(v2), h4.join()));
1901 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
1902 >                   Objects.equals(inc(v2), h5.join()));
1903  
1904 <        f = new CompletableFuture<>();
1905 <        f.completeExceptionally(new CFException());
1906 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
1907 <        checkCompletedWithWrappedCFException(g);
1908 <        assertFalse(r.ran);
1909 <    }
1904 >        checkCompletedNormally(f, v1);
1905 >        checkCompletedNormally(g, v2);
1906 >        checkCompletedNormally(h0, inc(v1));
1907 >        checkCompletedNormally(h1, inc(v1));
1908 >        checkCompletedNormally(h2, inc(v1));
1909 >        checkCompletedNormally(h3, inc(v1));
1910 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
1911 >    }}
1912  
1913      /**
1914 <     * thenComposeAsync result completes exceptionally if action does
1914 >     * applyToEither result completes exceptionally after exceptional
1915 >     * completion of either source
1916       */
1917 <    public void testThenComposeAsync3() {
1918 <        CompletableFuture<Integer> f, g;
1919 <        FailingCompletableFutureFunction r;
1917 >    public void testApplyToEither_exceptionalCompletion() {
1918 >        for (ExecutionMode m : ExecutionMode.values())
1919 >        for (Integer v1 : new Integer[] { 1, null })
1920 >    {
1921 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1922 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1923 >        final CFException ex = new CFException();
1924 >        final IncFunction[] rs = new IncFunction[6];
1925 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1926  
1927 <        f = new CompletableFuture<>();
1928 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
1929 <        f.complete(one);
1930 <        checkCompletedWithWrappedCFException(g);
1927 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1928 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1929 >        checkIncomplete(h0);
1930 >        checkIncomplete(h1);
1931 >        rs[0].assertNotInvoked();
1932 >        rs[1].assertNotInvoked();
1933 >        f.completeExceptionally(ex);
1934 >        checkCompletedWithWrappedException(h0, ex);
1935 >        checkCompletedWithWrappedException(h1, ex);
1936 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1937 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1938 >        checkCompletedWithWrappedException(h2, ex);
1939 >        checkCompletedWithWrappedException(h3, ex);
1940 >        g.complete(v1);
1941  
1942 <        f = new CompletableFuture<>();
1943 <        f.complete(one);
1944 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
1945 <        checkCompletedWithWrappedCFException(g);
1946 <    }
1942 >        // unspecified behavior - both source completions available
1943 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1944 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1945 >        try {
1946 >            assertEquals(inc(v1), h4.join());
1947 >            rs[4].assertValue(inc(v1));
1948 >        } catch (CompletionException ok) {
1949 >            checkCompletedWithWrappedException(h4, ex);
1950 >            rs[4].assertNotInvoked();
1951 >        }
1952 >        try {
1953 >            assertEquals(inc(v1), h5.join());
1954 >            rs[5].assertValue(inc(v1));
1955 >        } catch (CompletionException ok) {
1956 >            checkCompletedWithWrappedException(h5, ex);
1957 >            rs[5].assertNotInvoked();
1958 >        }
1959  
1960 <    /**
1961 <     * thenComposeAsync result completes exceptionally if source cancelled
1962 <     */
1963 <    public void testThenComposeAsync4() {
1964 <        CompletableFuture<Integer> f, g;
1965 <        CompletableFutureInc r;
1960 >        checkCompletedExceptionally(f, ex);
1961 >        checkCompletedNormally(g, v1);
1962 >        checkCompletedWithWrappedException(h0, ex);
1963 >        checkCompletedWithWrappedException(h1, ex);
1964 >        checkCompletedWithWrappedException(h2, ex);
1965 >        checkCompletedWithWrappedException(h3, ex);
1966 >        checkCompletedWithWrappedException(h4, ex);
1967 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1968 >    }}
1969  
1970 <        f = new CompletableFuture<>();
1971 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
1972 <        assertTrue(f.cancel(true));
1973 <        checkCompletedWithWrappedCancellationException(g);
1970 >    public void testApplyToEither_exceptionalCompletion2() {
1971 >        for (ExecutionMode m : ExecutionMode.values())
1972 >        for (boolean fFirst : new boolean[] { true, false })
1973 >        for (Integer v1 : new Integer[] { 1, null })
1974 >    {
1975 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1976 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1977 >        final CFException ex = new CFException();
1978 >        final IncFunction[] rs = new IncFunction[6];
1979 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1980  
1981 <        f = new CompletableFuture<>();
1982 <        assertTrue(f.cancel(true));
1983 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
1984 <        checkCompletedWithWrappedCancellationException(g);
1985 <    }
1981 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1982 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1983 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
1984 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
1985 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1986 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1987 >
1988 >        // unspecified behavior - both source completions available
1989 >        try {
1990 >            assertEquals(inc(v1), h0.join());
1991 >            rs[0].assertValue(inc(v1));
1992 >        } catch (CompletionException ok) {
1993 >            checkCompletedWithWrappedException(h0, ex);
1994 >            rs[0].assertNotInvoked();
1995 >        }
1996 >        try {
1997 >            assertEquals(inc(v1), h1.join());
1998 >            rs[1].assertValue(inc(v1));
1999 >        } catch (CompletionException ok) {
2000 >            checkCompletedWithWrappedException(h1, ex);
2001 >            rs[1].assertNotInvoked();
2002 >        }
2003 >        try {
2004 >            assertEquals(inc(v1), h2.join());
2005 >            rs[2].assertValue(inc(v1));
2006 >        } catch (CompletionException ok) {
2007 >            checkCompletedWithWrappedException(h2, ex);
2008 >            rs[2].assertNotInvoked();
2009 >        }
2010 >        try {
2011 >            assertEquals(inc(v1), h3.join());
2012 >            rs[3].assertValue(inc(v1));
2013 >        } catch (CompletionException ok) {
2014 >            checkCompletedWithWrappedException(h3, ex);
2015 >            rs[3].assertNotInvoked();
2016 >        }
2017  
2018 <    // async with explicit executors
2018 >        checkCompletedNormally(f, v1);
2019 >        checkCompletedExceptionally(g, ex);
2020 >    }}
2021  
2022      /**
2023 <     * thenRunAsync result completes normally after normal completion of source
2023 >     * applyToEither result completes exceptionally if either source cancelled
2024       */
2025 <    public void testThenRunAsyncE() {
2026 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2027 <        Noop r = new Noop();
2028 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2029 <        f.complete(null);
2030 <        checkCompletedNormally(g, null);
2031 <
2032 <        // reordered version
2033 <        f = new CompletableFuture<>();
2275 <        f.complete(null);
2276 <        r = new Noop();
2277 <        g = f.thenRunAsync(r, new ThreadExecutor());
2278 <        checkCompletedNormally(g, null);
2279 <    }
2025 >    public void testApplyToEither_sourceCancelled() {
2026 >        for (ExecutionMode m : ExecutionMode.values())
2027 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2028 >        for (Integer v1 : new Integer[] { 1, null })
2029 >    {
2030 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2031 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2032 >        final IncFunction[] rs = new IncFunction[6];
2033 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2034  
2035 <    /**
2036 <     * thenRunAsync result completes exceptionally after exceptional
2037 <     * completion of source
2038 <     */
2039 <    public void testThenRunAsync2E() {
2040 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2041 <        Noop r = new Noop();
2042 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2043 <        f.completeExceptionally(new CFException());
2044 <        try {
2045 <            g.join();
2046 <            shouldThrow();
2047 <        } catch (CompletionException success) {}
2048 <        checkCompletedWithWrappedCFException(g);
2295 <    }
2035 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2036 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2037 >        checkIncomplete(h0);
2038 >        checkIncomplete(h1);
2039 >        rs[0].assertNotInvoked();
2040 >        rs[1].assertNotInvoked();
2041 >        f.cancel(mayInterruptIfRunning);
2042 >        checkCompletedWithWrappedCancellationException(h0);
2043 >        checkCompletedWithWrappedCancellationException(h1);
2044 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2045 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2046 >        checkCompletedWithWrappedCancellationException(h2);
2047 >        checkCompletedWithWrappedCancellationException(h3);
2048 >        g.complete(v1);
2049  
2050 <    /**
2051 <     * thenRunAsync result completes exceptionally if action does
2052 <     */
2053 <    public void testThenRunAsync3E() {
2054 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2055 <        FailingNoop r = new FailingNoop();
2056 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2057 <        f.complete(null);
2058 <        checkCompletedWithWrappedCFException(g);
2059 <    }
2050 >        // unspecified behavior - both source completions available
2051 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2052 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2053 >        try {
2054 >            assertEquals(inc(v1), h4.join());
2055 >            rs[4].assertValue(inc(v1));
2056 >        } catch (CompletionException ok) {
2057 >            checkCompletedWithWrappedCancellationException(h4);
2058 >            rs[4].assertNotInvoked();
2059 >        }
2060 >        try {
2061 >            assertEquals(inc(v1), h5.join());
2062 >            rs[5].assertValue(inc(v1));
2063 >        } catch (CompletionException ok) {
2064 >            checkCompletedWithWrappedCancellationException(h5);
2065 >            rs[5].assertNotInvoked();
2066 >        }
2067  
2068 <    /**
2069 <     * thenRunAsync result completes exceptionally if source cancelled
2070 <     */
2071 <    public void testThenRunAsync4E() {
2072 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2073 <        Noop r = new Noop();
2074 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2075 <        assertTrue(f.cancel(true));
2316 <        checkCompletedWithWrappedCancellationException(g);
2317 <    }
2068 >        checkCancelled(f);
2069 >        checkCompletedNormally(g, v1);
2070 >        checkCompletedWithWrappedCancellationException(h0);
2071 >        checkCompletedWithWrappedCancellationException(h1);
2072 >        checkCompletedWithWrappedCancellationException(h2);
2073 >        checkCompletedWithWrappedCancellationException(h3);
2074 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2075 >    }}
2076  
2077 <    /**
2078 <     * thenApplyAsync result completes normally after normal completion of source
2079 <     */
2080 <    public void testThenApplyAsyncE() {
2081 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2082 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2083 <        f.complete(one);
2084 <        checkCompletedNormally(g, two);
2085 <    }
2077 >    public void testApplyToEither_sourceCancelled2() {
2078 >        for (ExecutionMode m : ExecutionMode.values())
2079 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2080 >        for (boolean fFirst : new boolean[] { true, false })
2081 >        for (Integer v1 : new Integer[] { 1, null })
2082 >    {
2083 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2084 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2085 >        final IncFunction[] rs = new IncFunction[6];
2086 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2087  
2088 <    /**
2089 <     * thenApplyAsync result completes exceptionally after exceptional
2090 <     * completion of source
2091 <     */
2092 <    public void testThenApplyAsync2E() {
2093 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2094 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2095 <        f.completeExceptionally(new CFException());
2096 <        checkCompletedWithWrappedCFException(g);
2097 <    }
2088 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2089 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2090 >        assertTrue(fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2091 >        assertTrue(!fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2092 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2093 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2094 >
2095 >        // unspecified behavior - both source completions available
2096 >        try {
2097 >            assertEquals(inc(v1), h0.join());
2098 >            rs[0].assertValue(inc(v1));
2099 >        } catch (CompletionException ok) {
2100 >            checkCompletedWithWrappedCancellationException(h0);
2101 >            rs[0].assertNotInvoked();
2102 >        }
2103 >        try {
2104 >            assertEquals(inc(v1), h1.join());
2105 >            rs[1].assertValue(inc(v1));
2106 >        } catch (CompletionException ok) {
2107 >            checkCompletedWithWrappedCancellationException(h1);
2108 >            rs[1].assertNotInvoked();
2109 >        }
2110 >        try {
2111 >            assertEquals(inc(v1), h2.join());
2112 >            rs[2].assertValue(inc(v1));
2113 >        } catch (CompletionException ok) {
2114 >            checkCompletedWithWrappedCancellationException(h2);
2115 >            rs[2].assertNotInvoked();
2116 >        }
2117 >        try {
2118 >            assertEquals(inc(v1), h3.join());
2119 >            rs[3].assertValue(inc(v1));
2120 >        } catch (CompletionException ok) {
2121 >            checkCompletedWithWrappedCancellationException(h3);
2122 >            rs[3].assertNotInvoked();
2123 >        }
2124  
2125 <    /**
2126 <     * thenApplyAsync result completes exceptionally if action does
2127 <     */
2343 <    public void testThenApplyAsync3E() {
2344 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2345 <        FailingFunction r = new FailingFunction();
2346 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2347 <        f.complete(null);
2348 <        checkCompletedWithWrappedCFException(g);
2349 <    }
2125 >        checkCompletedNormally(f, v1);
2126 >        checkCancelled(g);
2127 >    }}
2128  
2129      /**
2130 <     * thenApplyAsync result completes exceptionally if source cancelled
2130 >     * applyToEither result completes exceptionally if action does
2131       */
2132 <    public void testThenApplyAsync4E() {
2133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2134 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2135 <        assertTrue(f.cancel(true));
2136 <        checkCompletedWithWrappedCancellationException(g);
2137 <    }
2132 >    public void testApplyToEither_actionFailed() {
2133 >        for (ExecutionMode m : ExecutionMode.values())
2134 >        for (Integer v1 : new Integer[] { 1, null })
2135 >        for (Integer v2 : new Integer[] { 2, null })
2136 >    {
2137 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2138 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2139 >        final FailingFunction[] rs = new FailingFunction[6];
2140 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
2141  
2142 <    /**
2143 <     * thenAcceptAsync result completes normally after normal
2144 <     * completion of source
2145 <     */
2146 <    public void testThenAcceptAsyncE() {
2147 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2148 <        IncAction r = new IncAction();
2149 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2150 <        f.complete(one);
2151 <        checkCompletedNormally(g, null);
2371 <        assertEquals(r.value, 2);
2372 <    }
2142 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2143 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2144 >        f.complete(v1);
2145 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2146 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2147 >        checkCompletedWithWrappedCFException(h0);
2148 >        checkCompletedWithWrappedCFException(h1);
2149 >        checkCompletedWithWrappedCFException(h2);
2150 >        checkCompletedWithWrappedCFException(h3);
2151 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2152  
2153 <    /**
2375 <     * thenAcceptAsync result completes exceptionally after exceptional
2376 <     * completion of source
2377 <     */
2378 <    public void testThenAcceptAsync2E() {
2379 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2380 <        IncAction r = new IncAction();
2381 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2382 <        f.completeExceptionally(new CFException());
2383 <        checkCompletedWithWrappedCFException(g);
2384 <    }
2153 >        g.complete(v2);
2154  
2155 <    /**
2156 <     * thenAcceptAsync result completes exceptionally if action does
2157 <     */
2158 <    public void testThenAcceptAsync3E() {
2159 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2160 <        FailingConsumer r = new FailingConsumer();
2161 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2162 <        f.complete(null);
2163 <        checkCompletedWithWrappedCFException(g);
2164 <    }
2155 >        // unspecified behavior - both source completions available
2156 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2157 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2158 >
2159 >        checkCompletedWithWrappedCFException(h4);
2160 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2161 >                   Objects.equals(v2, rs[4].value));
2162 >        checkCompletedWithWrappedCFException(h5);
2163 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2164 >                   Objects.equals(v2, rs[5].value));
2165  
2166 <    /**
2167 <     * thenAcceptAsync result completes exceptionally if source cancelled
2168 <     */
2400 <    public void testThenAcceptAsync4E() {
2401 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2402 <        IncAction r = new IncAction();
2403 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2404 <        assertTrue(f.cancel(true));
2405 <        checkCompletedWithWrappedCancellationException(g);
2406 <    }
2166 >        checkCompletedNormally(f, v1);
2167 >        checkCompletedNormally(g, v2);
2168 >    }}
2169  
2170      /**
2171 <     * thenCombineAsync result completes normally after normal
2172 <     * completion of sources
2171 >     * acceptEither result completes normally after normal completion
2172 >     * of either source
2173       */
2174 <    public void testThenCombineAsyncE() {
2175 <        CompletableFuture<Integer> f, g, h;
2176 <        ThreadExecutor e = new ThreadExecutor();
2177 <        int count = 0;
2174 >    public void testAcceptEither_normalCompletion() {
2175 >        for (ExecutionMode m : ExecutionMode.values())
2176 >        for (Integer v1 : new Integer[] { 1, null })
2177 >        for (Integer v2 : new Integer[] { 2, null })
2178 >    {
2179 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2180 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2181 >        final NoopConsumer[] rs = new NoopConsumer[6];
2182 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2183  
2184 <        f = new CompletableFuture<>();
2185 <        g = new CompletableFuture<>();
2186 <        h = f.thenCombineAsync(g, subtract, e);
2187 <        f.complete(3);
2188 <        checkIncomplete(h);
2189 <        g.complete(1);
2190 <        checkCompletedNormally(h, 2);
2191 <        assertEquals(++count, e.count.get());
2184 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2185 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2186 >        checkIncomplete(h0);
2187 >        checkIncomplete(h1);
2188 >        rs[0].assertNotInvoked();
2189 >        rs[1].assertNotInvoked();
2190 >        f.complete(v1);
2191 >        checkCompletedNormally(h0, null);
2192 >        checkCompletedNormally(h1, null);
2193 >        rs[0].assertValue(v1);
2194 >        rs[1].assertValue(v1);
2195 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2196 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2197 >        checkCompletedNormally(h2, null);
2198 >        checkCompletedNormally(h3, null);
2199 >        rs[2].assertValue(v1);
2200 >        rs[3].assertValue(v1);
2201 >        g.complete(v2);
2202  
2203 <        f = new CompletableFuture<>();
2204 <        g = new CompletableFuture<>();
2205 <        h = f.thenCombineAsync(g, subtract, e);
2206 <        g.complete(1);
2207 <        checkIncomplete(h);
2208 <        f.complete(3);
2209 <        checkCompletedNormally(h, 2);
2210 <        assertEquals(++count, e.count.get());
2203 >        // unspecified behavior - both source completions available
2204 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2205 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2206 >        checkCompletedNormally(h4, null);
2207 >        checkCompletedNormally(h5, null);
2208 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2209 >                   Objects.equals(v2, rs[4].value));
2210 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2211 >                   Objects.equals(v2, rs[5].value));
2212  
2213 <        f = new CompletableFuture<>();
2214 <        g = new CompletableFuture<>();
2215 <        g.complete(1);
2216 <        f.complete(3);
2217 <        h = f.thenCombineAsync(g, subtract, e);
2218 <        checkCompletedNormally(h, 2);
2219 <        assertEquals(++count, e.count.get());
2220 <    }
2213 >        checkCompletedNormally(f, v1);
2214 >        checkCompletedNormally(g, v2);
2215 >        checkCompletedNormally(h0, null);
2216 >        checkCompletedNormally(h1, null);
2217 >        checkCompletedNormally(h2, null);
2218 >        checkCompletedNormally(h3, null);
2219 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2220 >    }}
2221  
2222      /**
2223 <     * thenCombineAsync result completes exceptionally after exceptional
2223 >     * acceptEither result completes exceptionally after exceptional
2224       * completion of either source
2225       */
2226 <    public void testThenCombineAsync2E() {
2227 <        CompletableFuture<Integer> f, g, h;
2228 <        ThreadExecutor e = new ThreadExecutor();
2229 <        int count = 0;
2230 <
2231 <        f = new CompletableFuture<>();
2232 <        g = new CompletableFuture<>();
2233 <        h = f.thenCombineAsync(g, subtract, e);
2234 <        f.completeExceptionally(new CFException());
2457 <        checkIncomplete(h);
2458 <        g.complete(1);
2459 <        checkCompletedWithWrappedCFException(h);
2460 <
2461 <        f = new CompletableFuture<>();
2462 <        g = new CompletableFuture<>();
2463 <        h = f.thenCombineAsync(g, subtract, e);
2464 <        g.completeExceptionally(new CFException());
2465 <        checkIncomplete(h);
2466 <        f.complete(3);
2467 <        checkCompletedWithWrappedCFException(h);
2468 <
2469 <        f = new CompletableFuture<>();
2470 <        g = new CompletableFuture<>();
2471 <        g.completeExceptionally(new CFException());
2472 <        h = f.thenCombineAsync(g, subtract, e);
2473 <        checkIncomplete(h);
2474 <        f.complete(3);
2475 <        checkCompletedWithWrappedCFException(h);
2476 <
2477 <        assertEquals(0, e.count.get());
2478 <    }
2226 >    public void testAcceptEither_exceptionalCompletion() {
2227 >        for (ExecutionMode m : ExecutionMode.values())
2228 >        for (Integer v1 : new Integer[] { 1, null })
2229 >    {
2230 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2231 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2232 >        final CFException ex = new CFException();
2233 >        final NoopConsumer[] rs = new NoopConsumer[6];
2234 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2235  
2236 <    /**
2237 <     * thenCombineAsync result completes exceptionally if action does
2238 <     */
2239 <    public void testThenCombineAsync3E() {
2240 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2241 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2242 <        FailingBiFunction r = new FailingBiFunction();
2243 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
2244 <        f.complete(one);
2245 <        checkIncomplete(g);
2246 <        assertFalse(r.ran);
2247 <        f2.complete(two);
2248 <        checkCompletedWithWrappedCFException(g);
2493 <        assertTrue(r.ran);
2494 <    }
2236 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2237 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2238 >        checkIncomplete(h0);
2239 >        checkIncomplete(h1);
2240 >        rs[0].assertNotInvoked();
2241 >        rs[1].assertNotInvoked();
2242 >        f.completeExceptionally(ex);
2243 >        checkCompletedWithWrappedException(h0, ex);
2244 >        checkCompletedWithWrappedException(h1, ex);
2245 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2246 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2247 >        checkCompletedWithWrappedException(h2, ex);
2248 >        checkCompletedWithWrappedException(h3, ex);
2249  
2250 <    /**
2497 <     * thenCombineAsync result completes exceptionally if either source cancelled
2498 <     */
2499 <    public void testThenCombineAsync4E() {
2500 <        CompletableFuture<Integer> f, g, h;
2501 <        ThreadExecutor e = new ThreadExecutor();
2250 >        g.complete(v1);
2251  
2252 <        f = new CompletableFuture<>();
2253 <        g = new CompletableFuture<>();
2254 <        h = f.thenCombineAsync(g, subtract, e);
2255 <        assertTrue(f.cancel(true));
2256 <        checkIncomplete(h);
2257 <        g.complete(1);
2258 <        checkCompletedWithWrappedCancellationException(h);
2252 >        // unspecified behavior - both source completions available
2253 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2254 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2255 >        try {
2256 >            assertNull(h4.join());
2257 >            rs[4].assertValue(v1);
2258 >        } catch (CompletionException ok) {
2259 >            checkCompletedWithWrappedException(h4, ex);
2260 >            rs[4].assertNotInvoked();
2261 >        }
2262 >        try {
2263 >            assertNull(h5.join());
2264 >            rs[5].assertValue(v1);
2265 >        } catch (CompletionException ok) {
2266 >            checkCompletedWithWrappedException(h5, ex);
2267 >            rs[5].assertNotInvoked();
2268 >        }
2269  
2270 <        f = new CompletableFuture<>();
2271 <        g = new CompletableFuture<>();
2272 <        h = f.thenCombineAsync(g, subtract, e);
2273 <        assertTrue(g.cancel(true));
2274 <        checkIncomplete(h);
2275 <        f.complete(3);
2276 <        checkCompletedWithWrappedCancellationException(h);
2270 >        checkCompletedExceptionally(f, ex);
2271 >        checkCompletedNormally(g, v1);
2272 >        checkCompletedWithWrappedException(h0, ex);
2273 >        checkCompletedWithWrappedException(h1, ex);
2274 >        checkCompletedWithWrappedException(h2, ex);
2275 >        checkCompletedWithWrappedException(h3, ex);
2276 >        checkCompletedWithWrappedException(h4, ex);
2277 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2278 >    }}
2279  
2280 <        f = new CompletableFuture<>();
2281 <        g = new CompletableFuture<>();
2282 <        assertTrue(g.cancel(true));
2283 <        h = f.thenCombineAsync(g, subtract, e);
2284 <        checkIncomplete(h);
2285 <        f.complete(3);
2286 <        checkCompletedWithWrappedCancellationException(h);
2280 >    public void testAcceptEither_exceptionalCompletion2() {
2281 >        for (ExecutionMode m : ExecutionMode.values())
2282 >        for (boolean fFirst : new boolean[] { true, false })
2283 >        for (Integer v1 : new Integer[] { 1, null })
2284 >    {
2285 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2286 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2287 >        final CFException ex = new CFException();
2288 >        final NoopConsumer[] rs = new NoopConsumer[6];
2289 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2290  
2291 <        f = new CompletableFuture<>();
2292 <        g = new CompletableFuture<>();
2293 <        assertTrue(f.cancel(true));
2294 <        assertTrue(g.cancel(true));
2295 <        h = f.thenCombineAsync(g, subtract, e);
2296 <        checkCompletedWithWrappedCancellationException(h);
2291 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2292 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2293 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2294 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2295 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2296 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2297 >
2298 >        // unspecified behavior - both source completions available
2299 >        try {
2300 >            assertEquals(null, h0.join());
2301 >            rs[0].assertValue(v1);
2302 >        } catch (CompletionException ok) {
2303 >            checkCompletedWithWrappedException(h0, ex);
2304 >            rs[0].assertNotInvoked();
2305 >        }
2306 >        try {
2307 >            assertEquals(null, h1.join());
2308 >            rs[1].assertValue(v1);
2309 >        } catch (CompletionException ok) {
2310 >            checkCompletedWithWrappedException(h1, ex);
2311 >            rs[1].assertNotInvoked();
2312 >        }
2313 >        try {
2314 >            assertEquals(null, h2.join());
2315 >            rs[2].assertValue(v1);
2316 >        } catch (CompletionException ok) {
2317 >            checkCompletedWithWrappedException(h2, ex);
2318 >            rs[2].assertNotInvoked();
2319 >        }
2320 >        try {
2321 >            assertEquals(null, h3.join());
2322 >            rs[3].assertValue(v1);
2323 >        } catch (CompletionException ok) {
2324 >            checkCompletedWithWrappedException(h3, ex);
2325 >            rs[3].assertNotInvoked();
2326 >        }
2327  
2328 <        assertEquals(0, e.count.get());
2329 <    }
2328 >        checkCompletedNormally(f, v1);
2329 >        checkCompletedExceptionally(g, ex);
2330 >    }}
2331  
2332      /**
2333 <     * thenAcceptBothAsync result completes normally after normal
2539 <     * completion of sources
2333 >     * acceptEither result completes exceptionally if either source cancelled
2334       */
2335 <    public void testThenAcceptBothAsyncE() {
2336 <        CompletableFuture<Integer> f, g;
2337 <        CompletableFuture<Void> h;
2338 <        SubtractAction r;
2339 <        ThreadExecutor e = new ThreadExecutor();
2335 >    public void testAcceptEither_sourceCancelled() {
2336 >        for (ExecutionMode m : ExecutionMode.values())
2337 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2338 >        for (Integer v1 : new Integer[] { 1, null })
2339 >    {
2340 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2341 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2342 >        final NoopConsumer[] rs = new NoopConsumer[6];
2343 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2344  
2345 <        f = new CompletableFuture<>();
2346 <        g = new CompletableFuture<>();
2347 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2348 <        f.complete(3);
2349 <        checkIncomplete(h);
2350 <        g.complete(1);
2351 <        checkCompletedNormally(h, null);
2352 <        assertEquals(r.value, 2);
2345 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2346 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2347 >        checkIncomplete(h0);
2348 >        checkIncomplete(h1);
2349 >        rs[0].assertNotInvoked();
2350 >        rs[1].assertNotInvoked();
2351 >        f.cancel(mayInterruptIfRunning);
2352 >        checkCompletedWithWrappedCancellationException(h0);
2353 >        checkCompletedWithWrappedCancellationException(h1);
2354 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2355 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2356 >        checkCompletedWithWrappedCancellationException(h2);
2357 >        checkCompletedWithWrappedCancellationException(h3);
2358  
2359 <        f = new CompletableFuture<>();
2557 <        g = new CompletableFuture<>();
2558 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2559 <        g.complete(1);
2560 <        checkIncomplete(h);
2561 <        f.complete(3);
2562 <        checkCompletedNormally(h, null);
2563 <        assertEquals(r.value, 2);
2359 >        g.complete(v1);
2360  
2361 <        f = new CompletableFuture<>();
2362 <        g = new CompletableFuture<>();
2363 <        g.complete(1);
2364 <        f.complete(3);
2365 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2366 <        checkCompletedNormally(h, null);
2367 <        assertEquals(r.value, 2);
2361 >        // unspecified behavior - both source completions available
2362 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2363 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2364 >        try {
2365 >            assertNull(h4.join());
2366 >            rs[4].assertValue(v1);
2367 >        } catch (CompletionException ok) {
2368 >            checkCompletedWithWrappedCancellationException(h4);
2369 >            rs[4].assertNotInvoked();
2370 >        }
2371 >        try {
2372 >            assertNull(h5.join());
2373 >            rs[5].assertValue(v1);
2374 >        } catch (CompletionException ok) {
2375 >            checkCompletedWithWrappedCancellationException(h5);
2376 >            rs[5].assertNotInvoked();
2377 >        }
2378  
2379 <        assertEquals(3, e.count.get());
2380 <    }
2379 >        checkCancelled(f);
2380 >        checkCompletedNormally(g, v1);
2381 >        checkCompletedWithWrappedCancellationException(h0);
2382 >        checkCompletedWithWrappedCancellationException(h1);
2383 >        checkCompletedWithWrappedCancellationException(h2);
2384 >        checkCompletedWithWrappedCancellationException(h3);
2385 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2386 >    }}
2387  
2388      /**
2389 <     * thenAcceptBothAsync result completes exceptionally after exceptional
2578 <     * completion of source
2389 >     * acceptEither result completes exceptionally if action does
2390       */
2391 <    public void testThenAcceptBothAsync2E() {
2392 <        CompletableFuture<Integer> f, g;
2393 <        CompletableFuture<Void> h;
2394 <        SubtractAction r;
2395 <        ThreadExecutor e = new ThreadExecutor();
2396 <
2397 <        f = new CompletableFuture<>();
2398 <        g = new CompletableFuture<>();
2399 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2589 <        f.completeExceptionally(new CFException());
2590 <        checkIncomplete(h);
2591 <        g.complete(1);
2592 <        checkCompletedWithWrappedCFException(h);
2593 <
2594 <        f = new CompletableFuture<>();
2595 <        g = new CompletableFuture<>();
2596 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2597 <        g.completeExceptionally(new CFException());
2598 <        checkIncomplete(h);
2599 <        f.complete(3);
2600 <        checkCompletedWithWrappedCFException(h);
2601 <
2602 <        f = new CompletableFuture<>();
2603 <        g = new CompletableFuture<>();
2604 <        f.complete(3);
2605 <        g.completeExceptionally(new CFException());
2606 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2607 <        checkCompletedWithWrappedCFException(h);
2608 <
2609 <        f = new CompletableFuture<>();
2610 <        g = new CompletableFuture<>();
2611 <        f.completeExceptionally(new CFException());
2612 <        g.complete(3);
2613 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2614 <        checkCompletedWithWrappedCFException(h);
2615 <
2616 <        assertEquals(0, e.count.get());
2617 <    }
2391 >    public void testAcceptEither_actionFailed() {
2392 >        for (ExecutionMode m : ExecutionMode.values())
2393 >        for (Integer v1 : new Integer[] { 1, null })
2394 >        for (Integer v2 : new Integer[] { 2, null })
2395 >    {
2396 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2397 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2398 >        final FailingConsumer[] rs = new FailingConsumer[6];
2399 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2400  
2401 <    /**
2402 <     * thenAcceptBothAsync result completes exceptionally if action does
2403 <     */
2404 <    public void testThenAcceptBothAsync3E() {
2405 <        CompletableFuture<Integer> f, g;
2406 <        CompletableFuture<Void> h;
2407 <        FailingBiConsumer r;
2408 <        ThreadExecutor e = new ThreadExecutor();
2401 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2402 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2403 >        f.complete(v1);
2404 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2405 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2406 >        checkCompletedWithWrappedCFException(h0);
2407 >        checkCompletedWithWrappedCFException(h1);
2408 >        checkCompletedWithWrappedCFException(h2);
2409 >        checkCompletedWithWrappedCFException(h3);
2410 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2411  
2412 <        f = new CompletableFuture<>();
2629 <        g = new CompletableFuture<>();
2630 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2631 <        f.complete(3);
2632 <        checkIncomplete(h);
2633 <        g.complete(1);
2634 <        checkCompletedWithWrappedCFException(h);
2412 >        g.complete(v2);
2413  
2414 <        f = new CompletableFuture<>();
2415 <        g = new CompletableFuture<>();
2416 <        f.complete(3);
2417 <        g.complete(1);
2418 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2419 <        checkCompletedWithWrappedCFException(h);
2414 >        // unspecified behavior - both source completions available
2415 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2416 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2417 >
2418 >        checkCompletedWithWrappedCFException(h4);
2419 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2420 >                   Objects.equals(v2, rs[4].value));
2421 >        checkCompletedWithWrappedCFException(h5);
2422 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2423 >                   Objects.equals(v2, rs[5].value));
2424  
2425 <        assertEquals(2, e.count.get());
2426 <    }
2425 >        checkCompletedNormally(f, v1);
2426 >        checkCompletedNormally(g, v2);
2427 >    }}
2428  
2429      /**
2430 <     * thenAcceptBothAsync result completes exceptionally if either source cancelled
2430 >     * runAfterEither result completes normally after normal completion
2431 >     * of either source
2432       */
2433 <    public void testThenAcceptBothAsync4E() {
2434 <        CompletableFuture<Integer> f, g;
2435 <        CompletableFuture<Void> h;
2436 <        SubtractAction r;
2437 <        ThreadExecutor e = new ThreadExecutor();
2438 <
2439 <        f = new CompletableFuture<>();
2440 <        g = new CompletableFuture<>();
2441 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2658 <        assertTrue(f.cancel(true));
2659 <        checkIncomplete(h);
2660 <        g.complete(1);
2661 <        checkCompletedWithWrappedCancellationException(h);
2433 >    public void testRunAfterEither_normalCompletion() {
2434 >        for (ExecutionMode m : ExecutionMode.values())
2435 >        for (Integer v1 : new Integer[] { 1, null })
2436 >        for (Integer v2 : new Integer[] { 2, null })
2437 >    {
2438 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2439 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2440 >        final Noop[] rs = new Noop[6];
2441 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2442  
2443 <        f = new CompletableFuture<>();
2444 <        g = new CompletableFuture<>();
2445 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2446 <        assertTrue(g.cancel(true));
2447 <        checkIncomplete(h);
2448 <        f.complete(3);
2449 <        checkCompletedWithWrappedCancellationException(h);
2443 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2444 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2445 >        checkIncomplete(h0);
2446 >        checkIncomplete(h1);
2447 >        rs[0].assertNotInvoked();
2448 >        rs[1].assertNotInvoked();
2449 >        f.complete(v1);
2450 >        checkCompletedNormally(h0, null);
2451 >        checkCompletedNormally(h1, null);
2452 >        rs[0].assertInvoked();
2453 >        rs[1].assertInvoked();
2454 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2455 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2456 >        checkCompletedNormally(h2, null);
2457 >        checkCompletedNormally(h3, null);
2458 >        rs[2].assertInvoked();
2459 >        rs[3].assertInvoked();
2460  
2461 <        f = new CompletableFuture<>();
2672 <        g = new CompletableFuture<>();
2673 <        f.complete(3);
2674 <        assertTrue(g.cancel(true));
2675 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2676 <        checkCompletedWithWrappedCancellationException(h);
2461 >        g.complete(v2);
2462  
2463 <        f = new CompletableFuture<>();
2464 <        g = new CompletableFuture<>();
2680 <        assertTrue(f.cancel(true));
2681 <        g.complete(3);
2682 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2683 <        checkCompletedWithWrappedCancellationException(h);
2463 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2464 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2465  
2466 <        assertEquals(0, e.count.get());
2467 <    }
2466 >        checkCompletedNormally(f, v1);
2467 >        checkCompletedNormally(g, v2);
2468 >        checkCompletedNormally(h0, null);
2469 >        checkCompletedNormally(h1, null);
2470 >        checkCompletedNormally(h2, null);
2471 >        checkCompletedNormally(h3, null);
2472 >        checkCompletedNormally(h4, null);
2473 >        checkCompletedNormally(h5, null);
2474 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2475 >    }}
2476  
2477      /**
2478 <     * applyToEitherAsync result completes normally after normal
2479 <     * completion of sources
2478 >     * runAfterEither result completes exceptionally after exceptional
2479 >     * completion of either source
2480       */
2481 <    public void testApplyToEitherAsyncE() {
2482 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2483 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2484 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2485 <        f.complete(one);
2486 <        checkCompletedNormally(g, two);
2487 <
2488 <        f = new CompletableFuture<>();
2489 <        f.complete(one);
2701 <        f2 = new CompletableFuture<>();
2702 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2703 <        checkCompletedNormally(g, two);
2704 <    }
2481 >    public void testRunAfterEither_exceptionalCompletion() {
2482 >        for (ExecutionMode m : ExecutionMode.values())
2483 >        for (Integer v1 : new Integer[] { 1, null })
2484 >    {
2485 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2486 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2487 >        final CFException ex = new CFException();
2488 >        final Noop[] rs = new Noop[6];
2489 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2490  
2491 <    /**
2492 <     * applyToEitherAsync result completes exceptionally after exceptional
2493 <     * completion of source
2494 <     */
2495 <    public void testApplyToEitherAsync2E() {
2496 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2497 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2498 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2499 <        f.completeExceptionally(new CFException());
2500 <        checkCompletedWithWrappedCFException(g);
2491 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2492 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2493 >        checkIncomplete(h0);
2494 >        checkIncomplete(h1);
2495 >        rs[0].assertNotInvoked();
2496 >        rs[1].assertNotInvoked();
2497 >        assertTrue(f.completeExceptionally(ex));
2498 >        checkCompletedWithWrappedException(h0, ex);
2499 >        checkCompletedWithWrappedException(h1, ex);
2500 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2501 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2502 >        checkCompletedWithWrappedException(h2, ex);
2503 >        checkCompletedWithWrappedException(h3, ex);
2504 >
2505 >        assertTrue(g.complete(v1));
2506 >
2507 >        // unspecified behavior - both source completions available
2508 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2509 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2510 >        try {
2511 >            assertNull(h4.join());
2512 >            rs[4].assertInvoked();
2513 >        } catch (CompletionException ok) {
2514 >            checkCompletedWithWrappedException(h4, ex);
2515 >            rs[4].assertNotInvoked();
2516 >        }
2517 >        try {
2518 >            assertNull(h5.join());
2519 >            rs[5].assertInvoked();
2520 >        } catch (CompletionException ok) {
2521 >            checkCompletedWithWrappedException(h5, ex);
2522 >            rs[5].assertNotInvoked();
2523 >        }
2524  
2525 <        f = new CompletableFuture<>();
2526 <        f2 = new CompletableFuture<>();
2527 <        f2.completeExceptionally(new CFException());
2528 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2529 <        f.complete(one);
2530 <        checkCompletedWithWrappedCFException(g);
2531 <    }
2525 >        checkCompletedExceptionally(f, ex);
2526 >        checkCompletedNormally(g, v1);
2527 >        checkCompletedWithWrappedException(h0, ex);
2528 >        checkCompletedWithWrappedException(h1, ex);
2529 >        checkCompletedWithWrappedException(h2, ex);
2530 >        checkCompletedWithWrappedException(h3, ex);
2531 >        checkCompletedWithWrappedException(h4, ex);
2532 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2533 >    }}
2534  
2535 <    /**
2536 <     * applyToEitherAsync result completes exceptionally if action does
2537 <     */
2538 <    public void testApplyToEitherAsync3E() {
2539 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2540 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2541 <        FailingFunction r = new FailingFunction();
2542 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
2543 <        f.complete(one);
2544 <        checkCompletedWithWrappedCFException(g);
2735 <    }
2535 >    public void testRunAfterEither_exceptionalCompletion2() {
2536 >        for (ExecutionMode m : ExecutionMode.values())
2537 >        for (boolean fFirst : new boolean[] { true, false })
2538 >        for (Integer v1 : new Integer[] { 1, null })
2539 >    {
2540 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2541 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2542 >        final CFException ex = new CFException();
2543 >        final Noop[] rs = new Noop[6];
2544 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2545  
2546 <    /**
2547 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2548 <     */
2549 <    public void testApplyToEitherAsync4E() {
2550 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2551 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2552 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2553 <        assertTrue(f.cancel(true));
2554 <        checkCompletedWithWrappedCancellationException(g);
2546 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2547 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2548 >        assertTrue( fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2549 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2550 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2551 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2552 >
2553 >        // unspecified behavior - both source completions available
2554 >        try {
2555 >            assertEquals(null, h0.join());
2556 >            rs[0].assertInvoked();
2557 >        } catch (CompletionException ok) {
2558 >            checkCompletedWithWrappedException(h0, ex);
2559 >            rs[0].assertNotInvoked();
2560 >        }
2561 >        try {
2562 >            assertEquals(null, h1.join());
2563 >            rs[1].assertInvoked();
2564 >        } catch (CompletionException ok) {
2565 >            checkCompletedWithWrappedException(h1, ex);
2566 >            rs[1].assertNotInvoked();
2567 >        }
2568 >        try {
2569 >            assertEquals(null, h2.join());
2570 >            rs[2].assertInvoked();
2571 >        } catch (CompletionException ok) {
2572 >            checkCompletedWithWrappedException(h2, ex);
2573 >            rs[2].assertNotInvoked();
2574 >        }
2575 >        try {
2576 >            assertEquals(null, h3.join());
2577 >            rs[3].assertInvoked();
2578 >        } catch (CompletionException ok) {
2579 >            checkCompletedWithWrappedException(h3, ex);
2580 >            rs[3].assertNotInvoked();
2581 >        }
2582  
2583 <        f = new CompletableFuture<>();
2584 <        f2 = new CompletableFuture<>();
2585 <        assertTrue(f2.cancel(true));
2750 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2751 <        checkCompletedWithWrappedCancellationException(g);
2752 <    }
2583 >        checkCompletedNormally(f, v1);
2584 >        checkCompletedExceptionally(g, ex);
2585 >    }}
2586  
2587      /**
2588 <     * acceptEitherAsync result completes normally after normal
2756 <     * completion of sources
2588 >     * runAfterEither result completes exceptionally if either source cancelled
2589       */
2590 <    public void testAcceptEitherAsyncE() {
2591 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2592 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2593 <        IncAction r = new IncAction();
2594 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2595 <        f.complete(one);
2596 <        checkCompletedNormally(g, null);
2597 <        assertEquals(r.value, 2);
2598 <
2767 <        r = new IncAction();
2768 <        f = new CompletableFuture<>();
2769 <        f.complete(one);
2770 <        f2 = new CompletableFuture<>();
2771 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2772 <        checkCompletedNormally(g, null);
2773 <        assertEquals(r.value, 2);
2774 <    }
2590 >    public void testRunAfterEither_sourceCancelled() {
2591 >        for (ExecutionMode m : ExecutionMode.values())
2592 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2593 >        for (Integer v1 : new Integer[] { 1, null })
2594 >    {
2595 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2596 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2597 >        final Noop[] rs = new Noop[6];
2598 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2599  
2600 <    /**
2601 <     * acceptEitherAsync result completes exceptionally after exceptional
2602 <     * completion of source
2603 <     */
2604 <    public void testAcceptEitherAsync2E() {
2605 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2606 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2607 <        IncAction r = new IncAction();
2608 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2609 <        f.completeExceptionally(new CFException());
2610 <        checkCompletedWithWrappedCFException(g);
2600 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2601 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2602 >        checkIncomplete(h0);
2603 >        checkIncomplete(h1);
2604 >        rs[0].assertNotInvoked();
2605 >        rs[1].assertNotInvoked();
2606 >        f.cancel(mayInterruptIfRunning);
2607 >        checkCompletedWithWrappedCancellationException(h0);
2608 >        checkCompletedWithWrappedCancellationException(h1);
2609 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2610 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2611 >        checkCompletedWithWrappedCancellationException(h2);
2612 >        checkCompletedWithWrappedCancellationException(h3);
2613 >
2614 >        assertTrue(g.complete(v1));
2615 >
2616 >        // unspecified behavior - both source completions available
2617 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2618 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2619 >        try {
2620 >            assertNull(h4.join());
2621 >            rs[4].assertInvoked();
2622 >        } catch (CompletionException ok) {
2623 >            checkCompletedWithWrappedCancellationException(h4);
2624 >            rs[4].assertNotInvoked();
2625 >        }
2626 >        try {
2627 >            assertNull(h5.join());
2628 >            rs[5].assertInvoked();
2629 >        } catch (CompletionException ok) {
2630 >            checkCompletedWithWrappedCancellationException(h5);
2631 >            rs[5].assertNotInvoked();
2632 >        }
2633  
2634 <        r = new IncAction();
2635 <        f = new CompletableFuture<>();
2636 <        f2 = new CompletableFuture<>();
2637 <        f2.completeExceptionally(new CFException());
2638 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2639 <        f.complete(one);
2640 <        checkCompletedWithWrappedCFException(g);
2641 <    }
2634 >        checkCancelled(f);
2635 >        checkCompletedNormally(g, v1);
2636 >        checkCompletedWithWrappedCancellationException(h0);
2637 >        checkCompletedWithWrappedCancellationException(h1);
2638 >        checkCompletedWithWrappedCancellationException(h2);
2639 >        checkCompletedWithWrappedCancellationException(h3);
2640 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2641 >    }}
2642  
2643      /**
2644 <     * acceptEitherAsync result completes exceptionally if action does
2644 >     * runAfterEither result completes exceptionally if action does
2645       */
2646 <    public void testAcceptEitherAsync3E() {
2647 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2648 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2649 <        FailingConsumer r = new FailingConsumer();
2650 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2651 <        f.complete(one);
2652 <        checkCompletedWithWrappedCFException(g);
2653 <    }
2646 >    public void testRunAfterEither_actionFailed() {
2647 >        for (ExecutionMode m : ExecutionMode.values())
2648 >        for (Integer v1 : new Integer[] { 1, null })
2649 >        for (Integer v2 : new Integer[] { 2, null })
2650 >    {
2651 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2652 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2653 >        final FailingRunnable[] rs = new FailingRunnable[6];
2654 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2655  
2656 <    /**
2657 <     * acceptEitherAsync result completes exceptionally if either
2658 <     * source cancelled
2659 <     */
2660 <    public void testAcceptEitherAsync4E() {
2661 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2662 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2663 <        IncAction r = new IncAction();
2664 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2665 <        assertTrue(f.cancel(true));
2666 <        checkCompletedWithWrappedCancellationException(g);
2656 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2657 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2658 >        assertTrue(f.complete(v1));
2659 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2660 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2661 >        checkCompletedWithWrappedCFException(h0);
2662 >        checkCompletedWithWrappedCFException(h1);
2663 >        checkCompletedWithWrappedCFException(h2);
2664 >        checkCompletedWithWrappedCFException(h3);
2665 >        for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2666 >        assertTrue(g.complete(v2));
2667 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2668 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2669 >        checkCompletedWithWrappedCFException(h4);
2670 >        checkCompletedWithWrappedCFException(h5);
2671  
2672 <        r = new IncAction();
2673 <        f = new CompletableFuture<>();
2674 <        f2 = new CompletableFuture<>();
2675 <        assertTrue(f2.cancel(true));
2825 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2826 <        checkCompletedWithWrappedCancellationException(g);
2827 <    }
2672 >        checkCompletedNormally(f, v1);
2673 >        checkCompletedNormally(g, v2);
2674 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2675 >    }}
2676  
2677      /**
2678 <     * runAfterEitherAsync result completes normally after normal
2831 <     * completion of sources
2678 >     * thenCompose result completes normally after normal completion of source
2679       */
2680 <    public void testRunAfterEitherAsyncE() {
2681 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2682 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2683 <        Noop r = new Noop();
2684 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2685 <        f.complete(one);
2686 <        checkCompletedNormally(g, null);
2687 <        assertTrue(r.ran);
2680 >    public void testThenCompose_normalCompletion() {
2681 >        for (ExecutionMode m : ExecutionMode.values())
2682 >        for (boolean createIncomplete : new boolean[] { true, false })
2683 >        for (Integer v1 : new Integer[] { 1, null })
2684 >    {
2685 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2686 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2687 >        if (!createIncomplete) assertTrue(f.complete(v1));
2688 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2689 >        if (createIncomplete) assertTrue(f.complete(v1));
2690  
2691 <        r = new Noop();
2692 <        f = new CompletableFuture<>();
2693 <        f.complete(one);
2694 <        f2 = new CompletableFuture<>();
2846 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2847 <        checkCompletedNormally(g, null);
2848 <        assertTrue(r.ran);
2849 <    }
2691 >        checkCompletedNormally(g, inc(v1));
2692 >        checkCompletedNormally(f, v1);
2693 >        r.assertValue(v1);
2694 >    }}
2695  
2696      /**
2697 <     * runAfterEitherAsync result completes exceptionally after exceptional
2697 >     * thenCompose result completes exceptionally after exceptional
2698       * completion of source
2699       */
2700 <    public void testRunAfterEitherAsync2E() {
2701 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2702 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2703 <        Noop r = new Noop();
2704 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2705 <        f.completeExceptionally(new CFException());
2706 <        checkCompletedWithWrappedCFException(g);
2707 <
2708 <        r = new Noop();
2709 <        f = new CompletableFuture<>();
2710 <        f2 = new CompletableFuture<>();
2711 <        f2.completeExceptionally(new CFException());
2712 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2713 <        f.complete(one);
2714 <        checkCompletedWithWrappedCFException(g);
2870 <    }
2871 <
2872 <    /**
2873 <     * runAfterEitherAsync result completes exceptionally if action does
2874 <     */
2875 <    public void testRunAfterEitherAsync3E() {
2876 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2877 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2878 <        FailingNoop r = new FailingNoop();
2879 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2880 <        f.complete(one);
2881 <        checkCompletedWithWrappedCFException(g);
2882 <    }
2883 <
2884 <    /**
2885 <     * runAfterEitherAsync result completes exceptionally if either
2886 <     * source cancelled
2887 <     */
2888 <    public void testRunAfterEitherAsync4E() {
2889 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2890 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2891 <        Noop r = new Noop();
2892 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2893 <        assertTrue(f.cancel(true));
2894 <        checkCompletedWithWrappedCancellationException(g);
2895 <
2896 <        r = new Noop();
2897 <        f = new CompletableFuture<>();
2898 <        f2 = new CompletableFuture<>();
2899 <        assertTrue(f2.cancel(true));
2900 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2901 <        checkCompletedWithWrappedCancellationException(g);
2902 <    }
2700 >    public void testThenCompose_exceptionalCompletion() {
2701 >        for (ExecutionMode m : ExecutionMode.values())
2702 >        for (boolean createIncomplete : new boolean[] { true, false })
2703 >    {
2704 >        final CFException ex = new CFException();
2705 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2706 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2707 >        if (!createIncomplete) f.completeExceptionally(ex);
2708 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2709 >        if (createIncomplete) f.completeExceptionally(ex);
2710 >
2711 >        checkCompletedWithWrappedException(g, ex);
2712 >        checkCompletedExceptionally(f, ex);
2713 >        r.assertNotInvoked();
2714 >    }}
2715  
2716      /**
2717 <     * thenComposeAsync result completes normally after normal
2906 <     * completion of source
2717 >     * thenCompose result completes exceptionally if action does
2718       */
2719 <    public void testThenComposeAsyncE() {
2720 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2721 <        CompletableFutureInc r = new CompletableFutureInc();
2722 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2723 <        f.complete(one);
2724 <        checkCompletedNormally(g, two);
2725 <    }
2719 >    public void testThenCompose_actionFailed() {
2720 >        for (ExecutionMode m : ExecutionMode.values())
2721 >        for (boolean createIncomplete : new boolean[] { true, false })
2722 >        for (Integer v1 : new Integer[] { 1, null })
2723 >    {
2724 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2725 >        final FailingCompletableFutureFunction r
2726 >            = new FailingCompletableFutureFunction(m);
2727 >        if (!createIncomplete) assertTrue(f.complete(v1));
2728 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2729 >        if (createIncomplete) assertTrue(f.complete(v1));
2730  
2916    /**
2917     * thenComposeAsync result completes exceptionally after
2918     * exceptional completion of source
2919     */
2920    public void testThenComposeAsync2E() {
2921        CompletableFuture<Integer> f = new CompletableFuture<>();
2922        CompletableFutureInc r = new CompletableFutureInc();
2923        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2924        f.completeExceptionally(new CFException());
2731          checkCompletedWithWrappedCFException(g);
2732 <    }
2732 >        checkCompletedNormally(f, v1);
2733 >    }}
2734  
2735      /**
2736 <     * thenComposeAsync result completes exceptionally if action does
2736 >     * thenCompose result completes exceptionally if source cancelled
2737       */
2738 <    public void testThenComposeAsync3E() {
2739 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2740 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2741 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2742 <        f.complete(one);
2743 <        checkCompletedWithWrappedCFException(g);
2744 <    }
2738 >    public void testThenCompose_sourceCancelled() {
2739 >        for (ExecutionMode m : ExecutionMode.values())
2740 >        for (boolean createIncomplete : new boolean[] { true, false })
2741 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2742 >    {
2743 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2744 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2745 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2746 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2747 >        if (createIncomplete) {
2748 >            checkIncomplete(g);
2749 >            assertTrue(f.cancel(mayInterruptIfRunning));
2750 >        }
2751  
2939    /**
2940     * thenComposeAsync result completes exceptionally if source cancelled
2941     */
2942    public void testThenComposeAsync4E() {
2943        CompletableFuture<Integer> f = new CompletableFuture<>();
2944        CompletableFutureInc r = new CompletableFutureInc();
2945        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2946        assertTrue(f.cancel(true));
2752          checkCompletedWithWrappedCancellationException(g);
2753 <    }
2753 >        checkCancelled(f);
2754 >    }}
2755  
2756      // other static methods
2757  
# Line 2964 | Line 2770 | public class CompletableFutureTest exten
2770       */
2771      public void testAllOf_normal() throws Exception {
2772          for (int k = 1; k < 20; ++k) {
2773 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2773 >            CompletableFuture<Integer>[] fs
2774 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2775              for (int i = 0; i < k; ++i)
2776                  fs[i] = new CompletableFuture<>();
2777              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
# Line 2978 | Line 2785 | public class CompletableFutureTest exten
2785          }
2786      }
2787  
2788 +    public void testAllOf_backwards() throws Exception {
2789 +        for (int k = 1; k < 20; ++k) {
2790 +            CompletableFuture<Integer>[] fs
2791 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2792 +            for (int i = 0; i < k; ++i)
2793 +                fs[i] = new CompletableFuture<>();
2794 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2795 +            for (int i = k - 1; i >= 0; i--) {
2796 +                checkIncomplete(f);
2797 +                checkIncomplete(CompletableFuture.allOf(fs));
2798 +                fs[i].complete(one);
2799 +            }
2800 +            checkCompletedNormally(f, null);
2801 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
2802 +        }
2803 +    }
2804 +
2805      /**
2806       * anyOf(no component futures) returns an incomplete future
2807       */
# Line 3036 | Line 2860 | public class CompletableFutureTest exten
2860          Runnable[] throwingActions = {
2861              () -> CompletableFuture.supplyAsync(null),
2862              () -> CompletableFuture.supplyAsync(null, exec),
2863 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
2863 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
2864  
2865              () -> CompletableFuture.runAsync(null),
2866              () -> CompletableFuture.runAsync(null, exec),
# Line 3109 | Line 2933 | public class CompletableFutureTest exten
2933  
2934              () -> f.thenCompose(null),
2935              () -> f.thenComposeAsync(null),
2936 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2936 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2937              () -> f.thenComposeAsync(null, exec),
2938  
2939              () -> f.exceptionally(null),
# Line 3141 | Line 2965 | public class CompletableFutureTest exten
2965          assertSame(f, f.toCompletableFuture());
2966      }
2967  
2968 <    /**
2969 <     * whenComplete action executes on normal completion, propagating
2970 <     * source result.
2971 <     */
2972 <    public void testWhenComplete1() {
2973 <        final AtomicInteger a = new AtomicInteger();
2974 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2975 <        CompletableFuture<Integer> g =
2976 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
2977 <        f.complete(three);
2978 <        checkCompletedNormally(f, three);
2979 <        checkCompletedNormally(g, three);
2980 <        assertEquals(a.get(), 1);
2981 <    }
2982 <
2983 <    /**
2984 <     * whenComplete action executes on exceptional completion, propagating
3161 <     * source result.
3162 <     */
3163 <    public void testWhenComplete2() {
3164 <        final AtomicInteger a = new AtomicInteger();
3165 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3166 <        CompletableFuture<Integer> g =
3167 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3168 <        f.completeExceptionally(new CFException());
3169 <        assertTrue(f.isCompletedExceptionally());
3170 <        assertTrue(g.isCompletedExceptionally());
3171 <        assertEquals(a.get(), 1);
3172 <    }
3173 <
3174 <    /**
3175 <     * If a whenComplete action throws an exception when triggered by
3176 <     * a normal completion, it completes exceptionally
3177 <     */
3178 <    public void testWhenComplete3() {
3179 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3180 <        CompletableFuture<Integer> g =
3181 <            f.whenComplete((Integer x, Throwable t) ->
3182 <                           { throw new CFException(); } );
3183 <        f.complete(three);
3184 <        checkCompletedNormally(f, three);
3185 <        assertTrue(g.isCompletedExceptionally());
3186 <        checkCompletedWithWrappedCFException(g);
3187 <    }
3188 <
3189 <    /**
3190 <     * whenCompleteAsync action executes on normal completion, propagating
3191 <     * source result.
3192 <     */
3193 <    public void testWhenCompleteAsync1() {
3194 <        final AtomicInteger a = new AtomicInteger();
3195 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3196 <        CompletableFuture<Integer> g =
3197 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3198 <        f.complete(three);
3199 <        checkCompletedNormally(f, three);
3200 <        checkCompletedNormally(g, three);
3201 <        assertEquals(a.get(), 1);
3202 <    }
3203 <
3204 <    /**
3205 <     * whenCompleteAsync action executes on exceptional completion, propagating
3206 <     * source result.
3207 <     */
3208 <    public void testWhenCompleteAsync2() {
3209 <        final AtomicInteger a = new AtomicInteger();
3210 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3211 <        CompletableFuture<Integer> g =
3212 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3213 <        f.completeExceptionally(new CFException());
3214 <        checkCompletedWithWrappedCFException(f);
3215 <        checkCompletedWithWrappedCFException(g);
3216 <    }
3217 <
3218 <    /**
3219 <     * If a whenCompleteAsync action throws an exception when
3220 <     * triggered by a normal completion, it completes exceptionally
3221 <     */
3222 <    public void testWhenCompleteAsync3() {
3223 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3224 <        CompletableFuture<Integer> g =
3225 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3226 <                           { throw new CFException(); } );
3227 <        f.complete(three);
3228 <        checkCompletedNormally(f, three);
3229 <        checkCompletedWithWrappedCFException(g);
3230 <    }
3231 <
3232 <    /**
3233 <     * whenCompleteAsync action executes on normal completion, propagating
3234 <     * source result.
3235 <     */
3236 <    public void testWhenCompleteAsync1e() {
3237 <        final AtomicInteger a = new AtomicInteger();
3238 <        ThreadExecutor exec = new ThreadExecutor();
3239 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3240 <        CompletableFuture<Integer> g =
3241 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3242 <                                exec);
3243 <        f.complete(three);
3244 <        checkCompletedNormally(f, three);
3245 <        checkCompletedNormally(g, three);
3246 <        assertEquals(a.get(), 1);
3247 <    }
3248 <
3249 <    /**
3250 <     * whenCompleteAsync action executes on exceptional completion, propagating
3251 <     * source result.
3252 <     */
3253 <    public void testWhenCompleteAsync2e() {
3254 <        final AtomicInteger a = new AtomicInteger();
3255 <        ThreadExecutor exec = new ThreadExecutor();
3256 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3257 <        CompletableFuture<Integer> g =
3258 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3259 <                                exec);
3260 <        f.completeExceptionally(new CFException());
3261 <        checkCompletedWithWrappedCFException(f);
3262 <        checkCompletedWithWrappedCFException(g);
3263 <    }
3264 <
3265 <    /**
3266 <     * If a whenCompleteAsync action throws an exception when triggered
3267 <     * by a normal completion, it completes exceptionally
3268 <     */
3269 <    public void testWhenCompleteAsync3e() {
3270 <        ThreadExecutor exec = new ThreadExecutor();
3271 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3272 <        CompletableFuture<Integer> g =
3273 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3274 <                                { throw new CFException(); },
3275 <                                exec);
3276 <        f.complete(three);
3277 <        checkCompletedNormally(f, three);
3278 <        checkCompletedWithWrappedCFException(g);
3279 <    }
3280 <
3281 <    /**
3282 <     * handleAsync action completes normally with function value on
3283 <     * either normal or exceptional completion of source
3284 <     */
3285 <    public void testHandleAsync() {
3286 <        CompletableFuture<Integer> f, g;
3287 <        IntegerHandler r;
3288 <
3289 <        f = new CompletableFuture<>();
3290 <        g = f.handleAsync(r = new IntegerHandler());
3291 <        assertFalse(r.ran);
3292 <        f.completeExceptionally(new CFException());
3293 <        checkCompletedWithWrappedCFException(f);
3294 <        checkCompletedNormally(g, three);
3295 <        assertTrue(r.ran);
3296 <
3297 <        f = new CompletableFuture<>();
3298 <        g = f.handleAsync(r = new IntegerHandler());
3299 <        assertFalse(r.ran);
3300 <        f.completeExceptionally(new CFException());
3301 <        checkCompletedWithWrappedCFException(f);
3302 <        checkCompletedNormally(g, three);
3303 <        assertTrue(r.ran);
3304 <
3305 <        f = new CompletableFuture<>();
3306 <        g = f.handleAsync(r = new IntegerHandler());
3307 <        assertFalse(r.ran);
3308 <        f.complete(one);
3309 <        checkCompletedNormally(f, one);
3310 <        checkCompletedNormally(g, two);
3311 <        assertTrue(r.ran);
3312 <
3313 <        f = new CompletableFuture<>();
3314 <        g = f.handleAsync(r = new IntegerHandler());
3315 <        assertFalse(r.ran);
3316 <        f.complete(one);
3317 <        checkCompletedNormally(f, one);
3318 <        checkCompletedNormally(g, two);
3319 <        assertTrue(r.ran);
3320 <    }
3321 <
3322 <    /**
3323 <     * handleAsync action with Executor completes normally with
3324 <     * function value on either normal or exceptional completion of
3325 <     * source
3326 <     */
3327 <    public void testHandleAsync2() {
3328 <        CompletableFuture<Integer> f, g;
3329 <        ThreadExecutor exec = new ThreadExecutor();
3330 <        IntegerHandler r;
3331 <
3332 <        f = new CompletableFuture<>();
3333 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3334 <        assertFalse(r.ran);
3335 <        f.completeExceptionally(new CFException());
3336 <        checkCompletedWithWrappedCFException(f);
3337 <        checkCompletedNormally(g, three);
3338 <        assertTrue(r.ran);
3339 <
3340 <        f = new CompletableFuture<>();
3341 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3342 <        assertFalse(r.ran);
3343 <        f.completeExceptionally(new CFException());
3344 <        checkCompletedWithWrappedCFException(f);
3345 <        checkCompletedNormally(g, three);
3346 <        assertTrue(r.ran);
3347 <
3348 <        f = new CompletableFuture<>();
3349 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3350 <        assertFalse(r.ran);
3351 <        f.complete(one);
3352 <        checkCompletedNormally(f, one);
3353 <        checkCompletedNormally(g, two);
3354 <        assertTrue(r.ran);
3355 <
3356 <        f = new CompletableFuture<>();
3357 <        g = f.handleAsync(r = new IntegerHandler(), exec);
3358 <        assertFalse(r.ran);
3359 <        f.complete(one);
3360 <        checkCompletedNormally(f, one);
3361 <        checkCompletedNormally(g, two);
3362 <        assertTrue(r.ran);
3363 <    }
2968 > //     public void testRunAfterEither_resultDeterminedAtTimeOfCreation() {
2969 > //         for (ExecutionMode m : ExecutionMode.values())
2970 > //         for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2971 > //         for (Integer v1 : new Integer[] { 1, null })
2972 > //     {
2973 > //         final CompletableFuture<Integer> f = new CompletableFuture<>();
2974 > //         final CompletableFuture<Integer> g = new CompletableFuture<>();
2975 > //         final Noop[] rs = new Noop[2];
2976 > //         for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2977 > //         f.complete(v1);
2978 > //         final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2979 > //         final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2980 > //         assertTrue(g.cancel(mayInterruptIfRunning));
2981 > //         checkCompletedNormally(h0, null);
2982 > //         checkCompletedNormally(h1, null);
2983 > //         for (Noop r : rs) r.assertInvoked();
2984 > //     }}
2985  
2986   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines