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.13 by jsr166, Sun Mar 31 18:17:18 2013 UTC vs.
Revision 1.80 by jsr166, Mon Jun 16 17:29:03 2014 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines