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

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.33 by jsr166, Sun Jun 1 20:40:13 2014 UTC vs.
Revision 1.97 by jsr166, Wed Dec 31 16:44:01 2014 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines