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.32 by jsr166, Mon May 26 17:25:36 2014 UTC vs.
Revision 1.187 by jsr166, Mon Jul 3 21:18:37 2017 UTC

# Line 5 | Line 5
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   */
7  
8 < import junit.framework.*;
8 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
9 > import static java.util.concurrent.TimeUnit.SECONDS;
10 > import static java.util.concurrent.CompletableFuture.completedFuture;
11 > import static java.util.concurrent.CompletableFuture.failedFuture;
12 >
13 > import java.lang.reflect.Method;
14 > import java.lang.reflect.Modifier;
15 >
16 > import java.util.stream.Collectors;
17 > import java.util.stream.Stream;
18 >
19 > import java.util.ArrayList;
20 > import java.util.Arrays;
21 > import java.util.List;
22 > import java.util.Objects;
23 > import java.util.Set;
24   import java.util.concurrent.Callable;
10 import java.util.concurrent.Executor;
11 import java.util.concurrent.ExecutorService;
12 import java.util.concurrent.Executors;
25   import java.util.concurrent.CancellationException;
14 import java.util.concurrent.CountDownLatch;
15 import java.util.concurrent.ExecutionException;
16 import java.util.concurrent.Future;
26   import java.util.concurrent.CompletableFuture;
27   import java.util.concurrent.CompletionException;
28 + import java.util.concurrent.CompletionStage;
29 + import java.util.concurrent.ExecutionException;
30 + import java.util.concurrent.Executor;
31 + import java.util.concurrent.ForkJoinPool;
32 + import java.util.concurrent.ForkJoinTask;
33 + import java.util.concurrent.RejectedExecutionException;
34   import java.util.concurrent.TimeoutException;
35   import java.util.concurrent.atomic.AtomicInteger;
36 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
22 < import static java.util.concurrent.TimeUnit.SECONDS;
23 < import java.util.*;
24 < import java.util.function.Supplier;
25 < import java.util.function.Consumer;
36 > import java.util.concurrent.atomic.AtomicReference;
37   import java.util.function.BiConsumer;
27 import java.util.function.Function;
38   import java.util.function.BiFunction;
39 + import java.util.function.Consumer;
40 + import java.util.function.Function;
41 + import java.util.function.Predicate;
42 + import java.util.function.Supplier;
43 +
44 + import junit.framework.AssertionFailedError;
45 + import junit.framework.Test;
46 + import junit.framework.TestSuite;
47  
48   public class CompletableFutureTest extends JSR166TestCase {
49  
50      public static void main(String[] args) {
51 <        junit.textui.TestRunner.run(suite());
51 >        main(suite(), args);
52      }
53      public static Test suite() {
54          return new TestSuite(CompletableFutureTest.class);
# Line 41 | Line 59 | public class CompletableFutureTest exten
59      void checkIncomplete(CompletableFuture<?> f) {
60          assertFalse(f.isDone());
61          assertFalse(f.isCancelled());
62 <        assertTrue(f.toString().contains("[Not completed]"));
62 >        assertTrue(f.toString().contains("Not completed"));
63          try {
64              assertNull(f.getNow(null));
65          } catch (Throwable fail) { threadUnexpectedException(fail); }
66          try {
67 <            f.get(0L, SECONDS);
67 >            f.get(randomExpiredTimeout(), randomTimeUnit());
68              shouldThrow();
69          }
70          catch (TimeoutException success) {}
# Line 54 | Line 72 | public class CompletableFutureTest exten
72      }
73  
74      <T> void checkCompletedNormally(CompletableFuture<T> f, T value) {
75 <        try {
76 <            assertEquals(value, f.get(LONG_DELAY_MS, MILLISECONDS));
59 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
75 >        checkTimedGet(f, value);
76 >
77          try {
78              assertEquals(value, f.join());
62        } catch (Throwable fail) { threadUnexpectedException(fail); }
63        try {
79              assertEquals(value, f.getNow(null));
65        } catch (Throwable fail) { threadUnexpectedException(fail); }
66        try {
80              assertEquals(value, f.get());
81          } catch (Throwable fail) { threadUnexpectedException(fail); }
82          assertTrue(f.isDone());
# Line 72 | Line 85 | public class CompletableFutureTest exten
85          assertTrue(f.toString().contains("[Completed normally]"));
86      }
87  
88 <    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
88 >    /**
89 >     * Returns the "raw" internal exceptional completion of f,
90 >     * without any additional wrapping with CompletionException.
91 >     */
92 >    Throwable exceptionalCompletion(CompletableFuture<?> f) {
93 >        // handle (and whenComplete and exceptionally) can distinguish
94 >        // between "direct" and "wrapped" exceptional completion
95 >        return f.handle((u, t) -> t).join();
96 >    }
97 >
98 >    void checkCompletedExceptionally(CompletableFuture<?> f,
99 >                                     boolean wrapped,
100 >                                     Consumer<Throwable> checker) {
101 >        Throwable cause = exceptionalCompletion(f);
102 >        if (wrapped) {
103 >            assertTrue(cause instanceof CompletionException);
104 >            cause = cause.getCause();
105 >        }
106 >        checker.accept(cause);
107 >
108 >        long startTime = System.nanoTime();
109          try {
110              f.get(LONG_DELAY_MS, MILLISECONDS);
111              shouldThrow();
112          } catch (ExecutionException success) {
113 <            assertTrue(success.getCause() instanceof CFException);
113 >            assertSame(cause, success.getCause());
114          } catch (Throwable fail) { threadUnexpectedException(fail); }
115 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
116 +
117          try {
118              f.join();
119              shouldThrow();
120          } catch (CompletionException success) {
121 <            assertTrue(success.getCause() instanceof CFException);
122 <        }
121 >            assertSame(cause, success.getCause());
122 >        } catch (Throwable fail) { threadUnexpectedException(fail); }
123 >
124          try {
125              f.getNow(null);
126              shouldThrow();
127          } catch (CompletionException success) {
128 <            assertTrue(success.getCause() instanceof CFException);
129 <        }
128 >            assertSame(cause, success.getCause());
129 >        } catch (Throwable fail) { threadUnexpectedException(fail); }
130 >
131          try {
132              f.get();
133              shouldThrow();
134          } catch (ExecutionException success) {
135 <            assertTrue(success.getCause() instanceof CFException);
135 >            assertSame(cause, success.getCause());
136          } catch (Throwable fail) { threadUnexpectedException(fail); }
137 <        assertTrue(f.isDone());
137 >
138          assertFalse(f.isCancelled());
139 +        assertTrue(f.isDone());
140 +        assertTrue(f.isCompletedExceptionally());
141          assertTrue(f.toString().contains("[Completed exceptionally]"));
142      }
143  
144 +    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
145 +        checkCompletedExceptionally(f, true,
146 +            t -> assertTrue(t instanceof CFException));
147 +    }
148 +
149 +    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
150 +        checkCompletedExceptionally(f, true,
151 +            t -> assertTrue(t instanceof CancellationException));
152 +    }
153 +
154 +    void checkCompletedWithTimeoutException(CompletableFuture<?> f) {
155 +        checkCompletedExceptionally(f, false,
156 +            t -> assertTrue(t instanceof TimeoutException));
157 +    }
158 +
159 +    void checkCompletedWithWrappedException(CompletableFuture<?> f,
160 +                                            Throwable ex) {
161 +        checkCompletedExceptionally(f, true, t -> assertSame(t, ex));
162 +    }
163 +
164 +    void checkCompletedExceptionally(CompletableFuture<?> f, Throwable ex) {
165 +        checkCompletedExceptionally(f, false, t -> assertSame(t, ex));
166 +    }
167 +
168      void checkCancelled(CompletableFuture<?> f) {
169 +        long startTime = System.nanoTime();
170          try {
171              f.get(LONG_DELAY_MS, MILLISECONDS);
172              shouldThrow();
173          } catch (CancellationException success) {
174          } catch (Throwable fail) { threadUnexpectedException(fail); }
175 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
176 +
177          try {
178              f.join();
179              shouldThrow();
# Line 121 | Line 187 | public class CompletableFutureTest exten
187              shouldThrow();
188          } catch (CancellationException success) {
189          } catch (Throwable fail) { threadUnexpectedException(fail); }
124        assertTrue(f.isDone());
125        assertTrue(f.isCompletedExceptionally());
126        assertTrue(f.isCancelled());
127        assertTrue(f.toString().contains("[Completed exceptionally]"));
128    }
190  
191 <    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
192 <        try {
132 <            f.get(LONG_DELAY_MS, MILLISECONDS);
133 <            shouldThrow();
134 <        } catch (ExecutionException success) {
135 <            assertTrue(success.getCause() instanceof CancellationException);
136 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
137 <        try {
138 <            f.join();
139 <            shouldThrow();
140 <        } catch (CompletionException success) {
141 <            assertTrue(success.getCause() instanceof CancellationException);
142 <        }
143 <        try {
144 <            f.getNow(null);
145 <            shouldThrow();
146 <        } catch (CompletionException success) {
147 <            assertTrue(success.getCause() instanceof CancellationException);
148 <        }
149 <        try {
150 <            f.get();
151 <            shouldThrow();
152 <        } catch (ExecutionException success) {
153 <            assertTrue(success.getCause() instanceof CancellationException);
154 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
191 >        assertTrue(exceptionalCompletion(f) instanceof CancellationException);
192 >
193          assertTrue(f.isDone());
156        assertFalse(f.isCancelled());
194          assertTrue(f.isCompletedExceptionally());
195 +        assertTrue(f.isCancelled());
196          assertTrue(f.toString().contains("[Completed exceptionally]"));
197      }
198  
# Line 172 | Line 210 | public class CompletableFutureTest exten
210       * isCancelled, join, get, and getNow
211       */
212      public void testComplete() {
213 +        for (Integer v1 : new Integer[] { 1, null })
214 +    {
215          CompletableFuture<Integer> f = new CompletableFuture<>();
216          checkIncomplete(f);
217 <        f.complete(one);
218 <        checkCompletedNormally(f, one);
219 <    }
217 >        assertTrue(f.complete(v1));
218 >        assertFalse(f.complete(v1));
219 >        checkCompletedNormally(f, v1);
220 >    }}
221  
222      /**
223       * completeExceptionally completes exceptionally, as indicated by
# Line 184 | Line 225 | public class CompletableFutureTest exten
225       */
226      public void testCompleteExceptionally() {
227          CompletableFuture<Integer> f = new CompletableFuture<>();
228 +        CFException ex = new CFException();
229          checkIncomplete(f);
230 <        f.completeExceptionally(new CFException());
231 <        checkCompletedWithWrappedCFException(f);
230 >        f.completeExceptionally(ex);
231 >        checkCompletedExceptionally(f, ex);
232      }
233  
234      /**
# Line 194 | Line 236 | public class CompletableFutureTest exten
236       * methods isDone, isCancelled, join, get, and getNow
237       */
238      public void testCancel() {
239 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
240 +    {
241          CompletableFuture<Integer> f = new CompletableFuture<>();
242          checkIncomplete(f);
243 <        assertTrue(f.cancel(true));
243 >        assertTrue(f.cancel(mayInterruptIfRunning));
244 >        assertTrue(f.cancel(mayInterruptIfRunning));
245 >        assertTrue(f.cancel(!mayInterruptIfRunning));
246          checkCancelled(f);
247 <    }
247 >    }}
248  
249      /**
250       * obtrudeValue forces completion with given value
# Line 206 | Line 252 | public class CompletableFutureTest exten
252      public void testObtrudeValue() {
253          CompletableFuture<Integer> f = new CompletableFuture<>();
254          checkIncomplete(f);
255 <        f.complete(one);
255 >        assertTrue(f.complete(one));
256          checkCompletedNormally(f, one);
257          f.obtrudeValue(three);
258          checkCompletedNormally(f, three);
# Line 215 | Line 261 | public class CompletableFutureTest exten
261          f = new CompletableFuture<>();
262          f.obtrudeValue(three);
263          checkCompletedNormally(f, three);
264 +        f.obtrudeValue(null);
265 +        checkCompletedNormally(f, null);
266          f = new CompletableFuture<>();
267          f.completeExceptionally(new CFException());
268          f.obtrudeValue(four);
# Line 225 | Line 273 | public class CompletableFutureTest exten
273       * obtrudeException forces completion with given exception
274       */
275      public void testObtrudeException() {
276 <        CompletableFuture<Integer> f = new CompletableFuture<>();
277 <        checkIncomplete(f);
278 <        f.complete(one);
279 <        checkCompletedNormally(f, one);
280 <        f.obtrudeException(new CFException());
233 <        checkCompletedWithWrappedCFException(f);
276 >        for (Integer v1 : new Integer[] { 1, null })
277 >    {
278 >        CFException ex;
279 >        CompletableFuture<Integer> f;
280 >
281          f = new CompletableFuture<>();
282 <        f.obtrudeException(new CFException());
283 <        checkCompletedWithWrappedCFException(f);
282 >        assertTrue(f.complete(v1));
283 >        for (int i = 0; i < 2; i++) {
284 >            f.obtrudeException(ex = new CFException());
285 >            checkCompletedExceptionally(f, ex);
286 >        }
287 >
288          f = new CompletableFuture<>();
289 <        f.completeExceptionally(new CFException());
290 <        f.obtrudeValue(four);
291 <        checkCompletedNormally(f, four);
292 <        f.obtrudeException(new CFException());
293 <        checkCompletedWithWrappedCFException(f);
294 <    }
289 >        for (int i = 0; i < 2; i++) {
290 >            f.obtrudeException(ex = new CFException());
291 >            checkCompletedExceptionally(f, ex);
292 >        }
293 >
294 >        f = new CompletableFuture<>();
295 >        f.completeExceptionally(ex = new CFException());
296 >        f.obtrudeValue(v1);
297 >        checkCompletedNormally(f, v1);
298 >        f.obtrudeException(ex = new CFException());
299 >        checkCompletedExceptionally(f, ex);
300 >        f.completeExceptionally(new CFException());
301 >        checkCompletedExceptionally(f, ex);
302 >        assertFalse(f.complete(v1));
303 >        checkCompletedExceptionally(f, ex);
304 >    }}
305  
306      /**
307       * getNumberOfDependents returns number of dependent tasks
308       */
309      public void testGetNumberOfDependents() {
310 <        CompletableFuture<Integer> f = new CompletableFuture<>();
311 <        assertEquals(f.getNumberOfDependents(), 0);
312 <        CompletableFuture g = f.thenRun(new Noop());
313 <        assertEquals(f.getNumberOfDependents(), 1);
314 <        assertEquals(g.getNumberOfDependents(), 0);
315 <        CompletableFuture h = f.thenRun(new Noop());
316 <        assertEquals(f.getNumberOfDependents(), 2);
317 <        f.complete(1);
310 >        for (ExecutionMode m : ExecutionMode.values())
311 >        for (Integer v1 : new Integer[] { 1, null })
312 >    {
313 >        CompletableFuture<Integer> f = new CompletableFuture<>();
314 >        assertEquals(0, f.getNumberOfDependents());
315 >        final CompletableFuture<Void> g = m.thenRun(f, new Noop(m));
316 >        assertEquals(1, f.getNumberOfDependents());
317 >        assertEquals(0, g.getNumberOfDependents());
318 >        final CompletableFuture<Void> h = m.thenRun(f, new Noop(m));
319 >        assertEquals(2, f.getNumberOfDependents());
320 >        assertEquals(0, h.getNumberOfDependents());
321 >        assertTrue(f.complete(v1));
322          checkCompletedNormally(g, null);
323 <        assertEquals(f.getNumberOfDependents(), 0);
324 <        assertEquals(g.getNumberOfDependents(), 0);
325 <    }
323 >        checkCompletedNormally(h, null);
324 >        assertEquals(0, f.getNumberOfDependents());
325 >        assertEquals(0, g.getNumberOfDependents());
326 >        assertEquals(0, h.getNumberOfDependents());
327 >    }}
328  
329      /**
330       * toString indicates current completion state
# Line 268 | Line 335 | public class CompletableFutureTest exten
335          f = new CompletableFuture<String>();
336          assertTrue(f.toString().contains("[Not completed]"));
337  
338 <        f.complete("foo");
338 >        assertTrue(f.complete("foo"));
339          assertTrue(f.toString().contains("[Completed normally]"));
340  
341          f = new CompletableFuture<String>();
342 <        f.completeExceptionally(new IndexOutOfBoundsException());
342 >        assertTrue(f.completeExceptionally(new IndexOutOfBoundsException()));
343          assertTrue(f.toString().contains("[Completed exceptionally]"));
344 +
345 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
346 +            f = new CompletableFuture<String>();
347 +            assertTrue(f.cancel(mayInterruptIfRunning));
348 +            assertTrue(f.toString().contains("[Completed exceptionally]"));
349 +        }
350      }
351  
352      /**
# Line 284 | Line 357 | public class CompletableFutureTest exten
357          checkCompletedNormally(f, "test");
358      }
359  
360 <    // Choose non-commutative actions for better coverage
361 <
362 <    static final Supplier<Integer> supplyOne =
363 <        () -> Integer.valueOf(1);
364 <    static final Function<Integer, Integer> inc =
365 <        (Integer x) -> Integer.valueOf(x.intValue() + 1);
366 <    static final BiFunction<Integer, Integer, Integer> subtract =
294 <        (Integer x, Integer y) -> Integer.valueOf(x.intValue() - y.intValue());
295 <    static final class IncAction implements Consumer<Integer> {
296 <        int value;
297 <        public void accept(Integer x) { value = x.intValue() + 1; }
298 <    }
299 <    static final class SubtractAction implements BiConsumer<Integer, Integer> {
300 <        int value;
301 <        public void accept(Integer x, Integer y) {
302 <            value = x.intValue() - y.intValue();
360 >    abstract static class CheckedAction {
361 >        int invocationCount = 0;
362 >        final ExecutionMode m;
363 >        CheckedAction(ExecutionMode m) { this.m = m; }
364 >        void invoked() {
365 >            m.checkExecutionMode();
366 >            assertEquals(0, invocationCount++);
367          }
368 <    }
369 <    static final class Noop implements Runnable {
306 <        boolean ran;
307 <        public void run() { ran = true; }
308 <    }
309 <
310 <    static final class FailingSupplier implements Supplier<Integer> {
311 <        boolean ran;
312 <        public Integer get() { ran = true; throw new CFException(); }
313 <    }
314 <    static final class FailingConsumer implements Consumer<Integer> {
315 <        boolean ran;
316 <        public void accept(Integer x) { ran = true; throw new CFException(); }
317 <    }
318 <    static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
319 <        boolean ran;
320 <        public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
321 <    }
322 <    static final class FailingFunction implements Function<Integer, Integer> {
323 <        boolean ran;
324 <        public Integer apply(Integer x) { ran = true; throw new CFException(); }
325 <    }
326 <    static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
327 <        boolean ran;
328 <        public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
329 <    }
330 <    static final class FailingNoop implements Runnable {
331 <        boolean ran;
332 <        public void run() { ran = true; throw new CFException(); }
368 >        void assertNotInvoked() { assertEquals(0, invocationCount); }
369 >        void assertInvoked() { assertEquals(1, invocationCount); }
370      }
371  
372 <    static final class CompletableFutureInc
373 <        implements Function<Integer, CompletableFuture<Integer>> {
374 <        boolean ran;
375 <        public CompletableFuture<Integer> apply(Integer x) {
376 <            ran = true;
377 <            CompletableFuture<Integer> f = new CompletableFuture<>();
341 <            f.complete(Integer.valueOf(x.intValue() + 1));
342 <            return f;
372 >    abstract static class CheckedIntegerAction extends CheckedAction {
373 >        Integer value;
374 >        CheckedIntegerAction(ExecutionMode m) { super(m); }
375 >        void assertValue(Integer expected) {
376 >            assertInvoked();
377 >            assertEquals(expected, value);
378          }
379      }
380  
381 <    static final class FailingCompletableFutureFunction
382 <        implements Function<Integer, CompletableFuture<Integer>> {
383 <        boolean ran;
384 <        public CompletableFuture<Integer> apply(Integer x) {
385 <            ran = true; throw new CFException();
381 >    static class IntegerSupplier extends CheckedAction
382 >        implements Supplier<Integer>
383 >    {
384 >        final Integer value;
385 >        IntegerSupplier(ExecutionMode m, Integer value) {
386 >            super(m);
387 >            this.value = value;
388          }
389 <    }
390 <
391 <    // Used for explicit executor tests
355 <    static final class ThreadExecutor implements Executor {
356 <        AtomicInteger count = new AtomicInteger(0);
357 <
358 <        public void execute(Runnable r) {
359 <            count.getAndIncrement();
360 <            new Thread(r).start();
389 >        public Integer get() {
390 >            invoked();
391 >            return value;
392          }
393      }
394  
395 <    static final class ExceptionToInteger implements Function<Throwable, Integer> {
396 <        public Integer apply(Throwable x) { return Integer.valueOf(3); }
395 >    // A function that handles and produces null values as well.
396 >    static Integer inc(Integer x) {
397 >        return (x == null) ? null : x + 1;
398      }
399  
400 <    static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
401 <        boolean ran;
402 <        public Integer apply(Integer x, Throwable t) {
403 <            ran = true;
404 <            return (t == null) ? two : three;
400 >    static class NoopConsumer extends CheckedIntegerAction
401 >        implements Consumer<Integer>
402 >    {
403 >        NoopConsumer(ExecutionMode m) { super(m); }
404 >        public void accept(Integer x) {
405 >            invoked();
406 >            value = x;
407          }
408      }
409  
410 <    /**
411 <     * exceptionally action completes with function value on source
412 <     * exception; otherwise with source value
413 <     */
414 <    public void testExceptionally() {
415 <        CompletableFuture<Integer> f = new CompletableFuture<>();
416 <        ExceptionToInteger r = new ExceptionToInteger();
417 <        CompletableFuture<Integer> g = f.exceptionally(r);
384 <        f.completeExceptionally(new CFException());
385 <        checkCompletedNormally(g, three);
386 <
387 <        f = new CompletableFuture<>();
388 <        r = new ExceptionToInteger();
389 <        g = f.exceptionally(r);
390 <        f.complete(one);
391 <        checkCompletedNormally(g, one);
392 <    }
393 <
394 <    /**
395 <     * handle action completes normally with function value on either
396 <     * normal or exceptional completion of source
397 <     */
398 <    public void testHandle() {
399 <        CompletableFuture<Integer> f, g;
400 <        IntegerHandler r;
401 <
402 <        f = new CompletableFuture<>();
403 <        f.completeExceptionally(new CFException());
404 <        g = f.handle(r = new IntegerHandler());
405 <        assertTrue(r.ran);
406 <        checkCompletedNormally(g, three);
407 <
408 <        f = new CompletableFuture<>();
409 <        g = f.handle(r = new IntegerHandler());
410 <        assertFalse(r.ran);
411 <        f.completeExceptionally(new CFException());
412 <        checkCompletedNormally(g, three);
413 <        assertTrue(r.ran);
414 <
415 <        f = new CompletableFuture<>();
416 <        f.complete(one);
417 <        g = f.handle(r = new IntegerHandler());
418 <        assertTrue(r.ran);
419 <        checkCompletedNormally(g, two);
420 <
421 <        f = new CompletableFuture<>();
422 <        g = f.handle(r = new IntegerHandler());
423 <        assertFalse(r.ran);
424 <        f.complete(one);
425 <        assertTrue(r.ran);
426 <        checkCompletedNormally(g, two);
427 <    }
428 <
429 <    /**
430 <     * runAsync completes after running Runnable
431 <     */
432 <    public void testRunAsync() {
433 <        Noop r = new Noop();
434 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
435 <        assertNull(f.join());
436 <        assertTrue(r.ran);
437 <        checkCompletedNormally(f, null);
438 <    }
439 <
440 <    /**
441 <     * runAsync with executor completes after running Runnable
442 <     */
443 <    public void testRunAsync2() {
444 <        Noop r = new Noop();
445 <        ThreadExecutor exec = new ThreadExecutor();
446 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
447 <        assertNull(f.join());
448 <        assertTrue(r.ran);
449 <        checkCompletedNormally(f, null);
450 <        assertEquals(1, exec.count.get());
451 <    }
452 <
453 <    /**
454 <     * failing runAsync completes exceptionally after running Runnable
455 <     */
456 <    public void testRunAsync3() {
457 <        FailingNoop r = new FailingNoop();
458 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
459 <        checkCompletedWithWrappedCFException(f);
460 <        assertTrue(r.ran);
461 <    }
462 <
463 <    /**
464 <     * supplyAsync completes with result of supplier
465 <     */
466 <    public void testSupplyAsync() {
467 <        CompletableFuture<Integer> f;
468 <        f = CompletableFuture.supplyAsync(supplyOne);
469 <        assertEquals(f.join(), one);
470 <        checkCompletedNormally(f, one);
471 <    }
472 <
473 <    /**
474 <     * supplyAsync with executor completes with result of supplier
475 <     */
476 <    public void testSupplyAsync2() {
477 <        CompletableFuture<Integer> f;
478 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
479 <        assertEquals(f.join(), one);
480 <        checkCompletedNormally(f, one);
481 <    }
482 <
483 <    /**
484 <     * Failing supplyAsync completes exceptionally
485 <     */
486 <    public void testSupplyAsync3() {
487 <        FailingSupplier r = new FailingSupplier();
488 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
489 <        checkCompletedWithWrappedCFException(f);
490 <        assertTrue(r.ran);
491 <    }
492 <
493 <    // seq completion methods
494 <
495 <    /**
496 <     * thenRun result completes normally after normal completion of source
497 <     */
498 <    public void testThenRun() {
499 <        CompletableFuture<Integer> f;
500 <        CompletableFuture<Void> g;
501 <        Noop r;
502 <
503 <        f = new CompletableFuture<>();
504 <        g = f.thenRun(r = new Noop());
505 <        f.complete(null);
506 <        checkCompletedNormally(g, null);
507 <        assertTrue(r.ran);
508 <
509 <        f = new CompletableFuture<>();
510 <        f.complete(null);
511 <        g = f.thenRun(r = new Noop());
512 <        checkCompletedNormally(g, null);
513 <        assertTrue(r.ran);
514 <    }
515 <
516 <    /**
517 <     * thenRun result completes exceptionally after exceptional
518 <     * completion of source
519 <     */
520 <    public void testThenRun2() {
521 <        CompletableFuture<Integer> f;
522 <        CompletableFuture<Void> g;
523 <        Noop r;
524 <
525 <        f = new CompletableFuture<>();
526 <        g = f.thenRun(r = new Noop());
527 <        f.completeExceptionally(new CFException());
528 <        checkCompletedWithWrappedCFException(g);
529 <        assertFalse(r.ran);
530 <
531 <        f = new CompletableFuture<>();
532 <        f.completeExceptionally(new CFException());
533 <        g = f.thenRun(r = new Noop());
534 <        checkCompletedWithWrappedCFException(g);
535 <        assertFalse(r.ran);
536 <    }
537 <
538 <    /**
539 <     * thenRun result completes exceptionally if action does
540 <     */
541 <    public void testThenRun3() {
542 <        CompletableFuture<Integer> f;
543 <        CompletableFuture<Void> g;
544 <        FailingNoop r;
545 <
546 <        f = new CompletableFuture<>();
547 <        g = f.thenRun(r = new FailingNoop());
548 <        f.complete(null);
549 <        checkCompletedWithWrappedCFException(g);
550 <
551 <        f = new CompletableFuture<>();
552 <        f.complete(null);
553 <        g = f.thenRun(r = new FailingNoop());
554 <        checkCompletedWithWrappedCFException(g);
555 <    }
556 <
557 <    /**
558 <     * thenRun result completes exceptionally if source cancelled
559 <     */
560 <    public void testThenRun4() {
561 <        CompletableFuture<Integer> f;
562 <        CompletableFuture<Void> g;
563 <        Noop r;
564 <
565 <        f = new CompletableFuture<>();
566 <        g = f.thenRun(r = new Noop());
567 <        assertTrue(f.cancel(true));
568 <        checkCompletedWithWrappedCancellationException(g);
569 <
570 <        f = new CompletableFuture<>();
571 <        assertTrue(f.cancel(true));
572 <        g = f.thenRun(r = new Noop());
573 <        checkCompletedWithWrappedCancellationException(g);
574 <    }
575 <
576 <    /**
577 <     * thenApply result completes normally after normal completion of source
578 <     */
579 <    public void testThenApply() {
580 <        CompletableFuture<Integer> f = new CompletableFuture<>();
581 <        CompletableFuture<Integer> g = f.thenApply(inc);
582 <        f.complete(one);
583 <        checkCompletedNormally(g, two);
584 <    }
585 <
586 <    /**
587 <     * thenApply result completes exceptionally after exceptional
588 <     * completion of source
589 <     */
590 <    public void testThenApply2() {
591 <        CompletableFuture<Integer> f = new CompletableFuture<>();
592 <        CompletableFuture<Integer> g = f.thenApply(inc);
593 <        f.completeExceptionally(new CFException());
594 <        checkCompletedWithWrappedCFException(g);
595 <    }
596 <
597 <    /**
598 <     * thenApply result completes exceptionally if action does
599 <     */
600 <    public void testThenApply3() {
601 <        CompletableFuture<Integer> f = new CompletableFuture<>();
602 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
603 <        f.complete(one);
604 <        checkCompletedWithWrappedCFException(g);
605 <    }
606 <
607 <    /**
608 <     * thenApply result completes exceptionally if source cancelled
609 <     */
610 <    public void testThenApply4() {
611 <        CompletableFuture<Integer> f = new CompletableFuture<>();
612 <        CompletableFuture<Integer> g = f.thenApply(inc);
613 <        assertTrue(f.cancel(true));
614 <        checkCompletedWithWrappedCancellationException(g);
615 <    }
616 <
617 <    /**
618 <     * thenAccept result completes normally after normal completion of source
619 <     */
620 <    public void testThenAccept() {
621 <        CompletableFuture<Integer> f = new CompletableFuture<>();
622 <        IncAction r = new IncAction();
623 <        CompletableFuture<Void> g = f.thenAccept(r);
624 <        f.complete(one);
625 <        checkCompletedNormally(g, null);
626 <        assertEquals(r.value, 2);
410 >    static class IncFunction extends CheckedIntegerAction
411 >        implements Function<Integer,Integer>
412 >    {
413 >        IncFunction(ExecutionMode m) { super(m); }
414 >        public Integer apply(Integer x) {
415 >            invoked();
416 >            return value = inc(x);
417 >        }
418      }
419  
420 <    /**
421 <     * thenAccept result completes exceptionally after exceptional
422 <     * completion of source
423 <     */
424 <    public void testThenAccept2() {
425 <        CompletableFuture<Integer> f = new CompletableFuture<>();
635 <        IncAction r = new IncAction();
636 <        CompletableFuture<Void> g = f.thenAccept(r);
637 <        f.completeExceptionally(new CFException());
638 <        checkCompletedWithWrappedCFException(g);
420 >    // Choose non-commutative actions for better coverage
421 >    // A non-commutative function that handles and produces null values as well.
422 >    static Integer subtract(Integer x, Integer y) {
423 >        return (x == null && y == null) ? null :
424 >            ((x == null) ? 42 : x.intValue())
425 >            - ((y == null) ? 99 : y.intValue());
426      }
427  
428 <    /**
429 <     * thenAccept result completes exceptionally if action does
430 <     */
431 <    public void testThenAccept3() {
432 <        CompletableFuture<Integer> f = new CompletableFuture<>();
433 <        FailingConsumer r = new FailingConsumer();
434 <        CompletableFuture<Void> g = f.thenAccept(r);
435 <        f.complete(one);
649 <        checkCompletedWithWrappedCFException(g);
650 <        assertTrue(r.ran);
428 >    static class SubtractAction extends CheckedIntegerAction
429 >        implements BiConsumer<Integer, Integer>
430 >    {
431 >        SubtractAction(ExecutionMode m) { super(m); }
432 >        public void accept(Integer x, Integer y) {
433 >            invoked();
434 >            value = subtract(x, y);
435 >        }
436      }
437  
438 <    /**
439 <     * thenAccept result completes exceptionally if source cancelled
440 <     */
441 <    public void testThenAccept4() {
442 <        CompletableFuture<Integer> f = new CompletableFuture<>();
443 <        IncAction r = new IncAction();
444 <        CompletableFuture<Void> g = f.thenAccept(r);
445 <        assertTrue(f.cancel(true));
661 <        checkCompletedWithWrappedCancellationException(g);
438 >    static class SubtractFunction extends CheckedIntegerAction
439 >        implements BiFunction<Integer, Integer, Integer>
440 >    {
441 >        SubtractFunction(ExecutionMode m) { super(m); }
442 >        public Integer apply(Integer x, Integer y) {
443 >            invoked();
444 >            return value = subtract(x, y);
445 >        }
446      }
447  
448 <    /**
449 <     * thenCombine result completes normally after normal completion
450 <     * of sources
451 <     */
452 <    public void testThenCombine() {
669 <        CompletableFuture<Integer> f, g, h;
670 <
671 <        f = new CompletableFuture<>();
672 <        g = new CompletableFuture<>();
673 <        h = f.thenCombine(g, subtract);
674 <        f.complete(3);
675 <        checkIncomplete(h);
676 <        g.complete(1);
677 <        checkCompletedNormally(h, 2);
678 <
679 <        f = new CompletableFuture<>();
680 <        g = new CompletableFuture<>();
681 <        h = f.thenCombine(g, subtract);
682 <        g.complete(1);
683 <        checkIncomplete(h);
684 <        f.complete(3);
685 <        checkCompletedNormally(h, 2);
686 <
687 <        f = new CompletableFuture<>();
688 <        g = new CompletableFuture<>();
689 <        g.complete(1);
690 <        f.complete(3);
691 <        h = f.thenCombine(g, subtract);
692 <        checkCompletedNormally(h, 2);
448 >    static class Noop extends CheckedAction implements Runnable {
449 >        Noop(ExecutionMode m) { super(m); }
450 >        public void run() {
451 >            invoked();
452 >        }
453      }
454  
455 <    /**
456 <     * thenCombine result completes exceptionally after exceptional
457 <     * completion of either source
458 <     */
459 <    public void testThenCombine2() {
460 <        CompletableFuture<Integer> f, g, h;
461 <
462 <        f = new CompletableFuture<>();
463 <        g = new CompletableFuture<>();
704 <        h = f.thenCombine(g, subtract);
705 <        f.completeExceptionally(new CFException());
706 <        checkIncomplete(h);
707 <        g.complete(1);
708 <        checkCompletedWithWrappedCFException(h);
709 <
710 <        f = new CompletableFuture<>();
711 <        g = new CompletableFuture<>();
712 <        h = f.thenCombine(g, subtract);
713 <        g.completeExceptionally(new CFException());
714 <        checkIncomplete(h);
715 <        f.complete(3);
716 <        checkCompletedWithWrappedCFException(h);
717 <
718 <        f = new CompletableFuture<>();
719 <        g = new CompletableFuture<>();
720 <        f.complete(3);
721 <        g.completeExceptionally(new CFException());
722 <        h = f.thenCombine(g, subtract);
723 <        checkCompletedWithWrappedCFException(h);
724 <
725 <        f = new CompletableFuture<>();
726 <        g = new CompletableFuture<>();
727 <        f.completeExceptionally(new CFException());
728 <        g.complete(3);
729 <        h = f.thenCombine(g, subtract);
730 <        checkCompletedWithWrappedCFException(h);
455 >    static class FailingSupplier extends CheckedAction
456 >        implements Supplier<Integer>
457 >    {
458 >        final CFException ex;
459 >        FailingSupplier(ExecutionMode m) { super(m); ex = new CFException(); }
460 >        public Integer get() {
461 >            invoked();
462 >            throw ex;
463 >        }
464      }
465  
466 <    /**
467 <     * thenCombine result completes exceptionally if action does
468 <     */
469 <    public void testThenCombine3() {
470 <        CompletableFuture<Integer> f = new CompletableFuture<>();
471 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
472 <        FailingBiFunction r = new FailingBiFunction();
473 <        CompletableFuture<Integer> g = f.thenCombine(f2, r);
474 <        f.complete(one);
475 <        checkIncomplete(g);
743 <        assertFalse(r.ran);
744 <        f2.complete(two);
745 <        checkCompletedWithWrappedCFException(g);
746 <        assertTrue(r.ran);
466 >    static class FailingConsumer extends CheckedIntegerAction
467 >        implements Consumer<Integer>
468 >    {
469 >        final CFException ex;
470 >        FailingConsumer(ExecutionMode m) { super(m); ex = new CFException(); }
471 >        public void accept(Integer x) {
472 >            invoked();
473 >            value = x;
474 >            throw ex;
475 >        }
476      }
477  
478 <    /**
479 <     * thenCombine result completes exceptionally if either source cancelled
480 <     */
481 <    public void testThenCombine4() {
482 <        CompletableFuture<Integer> f, g, h;
483 <
484 <        f = new CompletableFuture<>();
485 <        g = new CompletableFuture<>();
486 <        h = f.thenCombine(g, subtract);
487 <        assertTrue(f.cancel(true));
759 <        checkIncomplete(h);
760 <        g.complete(1);
761 <        checkCompletedWithWrappedCancellationException(h);
762 <
763 <        f = new CompletableFuture<>();
764 <        g = new CompletableFuture<>();
765 <        h = f.thenCombine(g, subtract);
766 <        assertTrue(g.cancel(true));
767 <        checkIncomplete(h);
768 <        f.complete(3);
769 <        checkCompletedWithWrappedCancellationException(h);
770 <
771 <        f = new CompletableFuture<>();
772 <        g = new CompletableFuture<>();
773 <        assertTrue(f.cancel(true));
774 <        assertTrue(g.cancel(true));
775 <        h = f.thenCombine(g, subtract);
776 <        checkCompletedWithWrappedCancellationException(h);
478 >    static class FailingBiConsumer extends CheckedIntegerAction
479 >        implements BiConsumer<Integer, Integer>
480 >    {
481 >        final CFException ex;
482 >        FailingBiConsumer(ExecutionMode m) { super(m); ex = new CFException(); }
483 >        public void accept(Integer x, Integer y) {
484 >            invoked();
485 >            value = subtract(x, y);
486 >            throw ex;
487 >        }
488      }
489  
490 <    /**
491 <     * thenAcceptBoth result completes normally after normal
492 <     * completion of sources
493 <     */
494 <    public void testThenAcceptBoth() {
495 <        CompletableFuture<Integer> f, g;
496 <        CompletableFuture<Void> h;
497 <        SubtractAction r;
498 <
499 <        f = new CompletableFuture<>();
789 <        g = new CompletableFuture<>();
790 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
791 <        f.complete(3);
792 <        checkIncomplete(h);
793 <        g.complete(1);
794 <        checkCompletedNormally(h, null);
795 <        assertEquals(r.value, 2);
796 <
797 <        f = new CompletableFuture<>();
798 <        g = new CompletableFuture<>();
799 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
800 <        g.complete(1);
801 <        checkIncomplete(h);
802 <        f.complete(3);
803 <        checkCompletedNormally(h, null);
804 <        assertEquals(r.value, 2);
805 <
806 <        f = new CompletableFuture<>();
807 <        g = new CompletableFuture<>();
808 <        g.complete(1);
809 <        f.complete(3);
810 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
811 <        checkCompletedNormally(h, null);
812 <        assertEquals(r.value, 2);
490 >    static class FailingFunction extends CheckedIntegerAction
491 >        implements Function<Integer, Integer>
492 >    {
493 >        final CFException ex;
494 >        FailingFunction(ExecutionMode m) { super(m); ex = new CFException(); }
495 >        public Integer apply(Integer x) {
496 >            invoked();
497 >            value = x;
498 >            throw ex;
499 >        }
500      }
501  
502 <    /**
503 <     * thenAcceptBoth result completes exceptionally after exceptional
504 <     * completion of either source
505 <     */
506 <    public void testThenAcceptBoth2() {
507 <        CompletableFuture<Integer> f, g;
508 <        CompletableFuture<Void> h;
509 <        SubtractAction r;
510 <
511 <        f = new CompletableFuture<>();
825 <        g = new CompletableFuture<>();
826 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
827 <        f.completeExceptionally(new CFException());
828 <        checkIncomplete(h);
829 <        g.complete(1);
830 <        checkCompletedWithWrappedCFException(h);
831 <
832 <        f = new CompletableFuture<>();
833 <        g = new CompletableFuture<>();
834 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
835 <        g.completeExceptionally(new CFException());
836 <        checkIncomplete(h);
837 <        f.complete(3);
838 <        checkCompletedWithWrappedCFException(h);
839 <
840 <        f = new CompletableFuture<>();
841 <        g = new CompletableFuture<>();
842 <        f.complete(3);
843 <        g.completeExceptionally(new CFException());
844 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
845 <        checkCompletedWithWrappedCFException(h);
846 <
847 <        f = new CompletableFuture<>();
848 <        g = new CompletableFuture<>();
849 <        f.completeExceptionally(new CFException());
850 <        g.complete(3);
851 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
852 <        checkCompletedWithWrappedCFException(h);
502 >    static class FailingBiFunction extends CheckedIntegerAction
503 >        implements BiFunction<Integer, Integer, Integer>
504 >    {
505 >        final CFException ex;
506 >        FailingBiFunction(ExecutionMode m) { super(m); ex = new CFException(); }
507 >        public Integer apply(Integer x, Integer y) {
508 >            invoked();
509 >            value = subtract(x, y);
510 >            throw ex;
511 >        }
512      }
513  
514 <    /**
515 <     * thenAcceptBoth result completes exceptionally if action does
516 <     */
517 <    public void testThenAcceptBoth3() {
518 <        CompletableFuture<Integer> f, g;
519 <        CompletableFuture<Void> h;
520 <        FailingBiConsumer r;
862 <
863 <        f = new CompletableFuture<>();
864 <        g = new CompletableFuture<>();
865 <        h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
866 <        f.complete(3);
867 <        checkIncomplete(h);
868 <        g.complete(1);
869 <        checkCompletedWithWrappedCFException(h);
870 <
871 <        f = new CompletableFuture<>();
872 <        g = new CompletableFuture<>();
873 <        f.complete(3);
874 <        g.complete(1);
875 <        h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
876 <        checkCompletedWithWrappedCFException(h);
514 >    static class FailingRunnable extends CheckedAction implements Runnable {
515 >        final CFException ex;
516 >        FailingRunnable(ExecutionMode m) { super(m); ex = new CFException(); }
517 >        public void run() {
518 >            invoked();
519 >            throw ex;
520 >        }
521      }
522  
523 <    /**
524 <     * thenAcceptBoth result completes exceptionally if either source cancelled
525 <     */
526 <    public void testThenAcceptBoth4() {
527 <        CompletableFuture<Integer> f, g;
528 <        CompletableFuture<Void> h;
529 <        SubtractAction r;
530 <
531 <        f = new CompletableFuture<>();
532 <        g = new CompletableFuture<>();
533 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
890 <        assertTrue(f.cancel(true));
891 <        checkIncomplete(h);
892 <        g.complete(1);
893 <        checkCompletedWithWrappedCancellationException(h);
894 <
895 <        f = new CompletableFuture<>();
896 <        g = new CompletableFuture<>();
897 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
898 <        assertTrue(g.cancel(true));
899 <        checkIncomplete(h);
900 <        f.complete(3);
901 <        checkCompletedWithWrappedCancellationException(h);
902 <
903 <        f = new CompletableFuture<>();
904 <        g = new CompletableFuture<>();
905 <        f.complete(3);
906 <        assertTrue(g.cancel(true));
907 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
908 <        checkCompletedWithWrappedCancellationException(h);
909 <
910 <        f = new CompletableFuture<>();
911 <        g = new CompletableFuture<>();
912 <        assertTrue(f.cancel(true));
913 <        g.complete(3);
914 <        h = f.thenAcceptBoth(g, r = new SubtractAction());
915 <        checkCompletedWithWrappedCancellationException(h);
523 >    static class CompletableFutureInc extends CheckedIntegerAction
524 >        implements Function<Integer, CompletableFuture<Integer>>
525 >    {
526 >        CompletableFutureInc(ExecutionMode m) { super(m); }
527 >        public CompletableFuture<Integer> apply(Integer x) {
528 >            invoked();
529 >            value = x;
530 >            CompletableFuture<Integer> f = new CompletableFuture<>();
531 >            assertTrue(f.complete(inc(x)));
532 >            return f;
533 >        }
534      }
535  
536 <    /**
537 <     * runAfterBoth result completes normally after normal
538 <     * completion of sources
539 <     */
540 <    public void testRunAfterBoth() {
541 <        CompletableFuture<Integer> f, g;
542 <        CompletableFuture<Void> h;
543 <        Noop r;
544 <
545 <        f = new CompletableFuture<>();
928 <        g = new CompletableFuture<>();
929 <        h = f.runAfterBoth(g, r = new Noop());
930 <        f.complete(3);
931 <        checkIncomplete(h);
932 <        g.complete(1);
933 <        checkCompletedNormally(h, null);
934 <        assertTrue(r.ran);
935 <
936 <        f = new CompletableFuture<>();
937 <        g = new CompletableFuture<>();
938 <        h = f.runAfterBoth(g, r = new Noop());
939 <        g.complete(1);
940 <        checkIncomplete(h);
941 <        f.complete(3);
942 <        checkCompletedNormally(h, null);
943 <        assertTrue(r.ran);
944 <
945 <        f = new CompletableFuture<>();
946 <        g = new CompletableFuture<>();
947 <        g.complete(1);
948 <        f.complete(3);
949 <        h = f.runAfterBoth(g, r = new Noop());
950 <        checkCompletedNormally(h, null);
951 <        assertTrue(r.ran);
536 >    static class FailingCompletableFutureFunction extends CheckedIntegerAction
537 >        implements Function<Integer, CompletableFuture<Integer>>
538 >    {
539 >        final CFException ex;
540 >        FailingCompletableFutureFunction(ExecutionMode m) { super(m); ex = new CFException(); }
541 >        public CompletableFuture<Integer> apply(Integer x) {
542 >            invoked();
543 >            value = x;
544 >            throw ex;
545 >        }
546      }
547  
548 <    /**
549 <     * runAfterBoth result completes exceptionally after exceptional
550 <     * completion of either source
551 <     */
552 <    public void testRunAfterBoth2() {
553 <        CompletableFuture<Integer> f, g;
554 <        CompletableFuture<Void> h;
961 <        Noop r;
962 <
963 <        f = new CompletableFuture<>();
964 <        g = new CompletableFuture<>();
965 <        h = f.runAfterBoth(g, r = new Noop());
966 <        f.completeExceptionally(new CFException());
967 <        checkIncomplete(h);
968 <        g.complete(1);
969 <        checkCompletedWithWrappedCFException(h);
970 <        assertFalse(r.ran);
971 <
972 <        f = new CompletableFuture<>();
973 <        g = new CompletableFuture<>();
974 <        h = f.runAfterBoth(g, r = new Noop());
975 <        g.completeExceptionally(new CFException());
976 <        checkIncomplete(h);
977 <        f.complete(3);
978 <        checkCompletedWithWrappedCFException(h);
979 <        assertFalse(r.ran);
980 <
981 <        f = new CompletableFuture<>();
982 <        g = new CompletableFuture<>();
983 <        g.completeExceptionally(new CFException());
984 <        f.complete(3);
985 <        h = f.runAfterBoth(g, r = new Noop());
986 <        checkCompletedWithWrappedCFException(h);
987 <        assertFalse(r.ran);
988 <
989 <        f = new CompletableFuture<>();
990 <        g = new CompletableFuture<>();
991 <        f.completeExceptionally(new CFException());
992 <        g.complete(1);
993 <        h = f.runAfterBoth(g, r = new Noop());
994 <        checkCompletedWithWrappedCFException(h);
995 <        assertFalse(r.ran);
548 >    static class CountingRejectingExecutor implements Executor {
549 >        final RejectedExecutionException ex = new RejectedExecutionException();
550 >        final AtomicInteger count = new AtomicInteger(0);
551 >        public void execute(Runnable r) {
552 >            count.getAndIncrement();
553 >            throw ex;
554 >        }
555      }
556  
557 <    /**
558 <     * runAfterBoth result completes exceptionally if action does
559 <     */
560 <    public void testRunAfterBoth3() {
561 <        CompletableFuture<Integer> f = new CompletableFuture<>();
562 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
563 <        FailingNoop r = new FailingNoop();
1005 <        CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1006 <        f.complete(one);
1007 <        checkIncomplete(g);
1008 <        f2.complete(two);
1009 <        checkCompletedWithWrappedCFException(g);
1010 <    }
557 >    // Used for explicit executor tests
558 >    static final class ThreadExecutor implements Executor {
559 >        final AtomicInteger count = new AtomicInteger(0);
560 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
561 >        static boolean startedCurrentThread() {
562 >            return Thread.currentThread().getThreadGroup() == tg;
563 >        }
564  
565 <    /**
566 <     * runAfterBoth result completes exceptionally if either source cancelled
567 <     */
568 <    public void testRunAfterBoth4() {
1016 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1017 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1018 <        Noop r = new Noop();
1019 <        CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1020 <        assertTrue(f.cancel(true));
1021 <        f2.complete(two);
1022 <        checkCompletedWithWrappedCancellationException(g);
1023 <        f = new CompletableFuture<>();
1024 <        f2 = new CompletableFuture<>();
1025 <        r = new Noop();
1026 <        g = f.runAfterBoth(f2, r);
1027 <        f.complete(one);
1028 <        assertTrue(f2.cancel(true));
1029 <        checkCompletedWithWrappedCancellationException(g);
565 >        public void execute(Runnable r) {
566 >            count.getAndIncrement();
567 >            new Thread(tg, r).start();
568 >        }
569      }
570  
571 <    /**
572 <     * applyToEither result completes normally after normal completion
1034 <     * of either source
1035 <     */
1036 <    public void testApplyToEither() {
1037 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1038 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1039 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1040 <        f.complete(one);
1041 <        checkCompletedNormally(g, two);
1042 <        f2.complete(one);
1043 <        checkCompletedNormally(g, two);
1044 <
1045 <        f = new CompletableFuture<>();
1046 <        f.complete(one);
1047 <        f2 = new CompletableFuture<>();
1048 <        g = f.applyToEither(f2, inc);
1049 <        checkCompletedNormally(g, two);
1050 <    }
571 >    static final boolean defaultExecutorIsCommonPool
572 >        = ForkJoinPool.getCommonPoolParallelism() > 1;
573  
574      /**
575 <     * applyToEither result completes exceptionally after exceptional
576 <     * completion of either source
575 >     * Permits the testing of parallel code for the 3 different
576 >     * execution modes without copy/pasting all the test methods.
577       */
578 <    public void testApplyToEither2() {
579 <        CompletableFuture<Integer> f = new CompletableFuture<>();
580 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
581 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
582 <        f.completeExceptionally(new CFException());
583 <        f2.complete(one);
584 <        checkCompletedWithWrappedCFException(g);
578 >    enum ExecutionMode {
579 >        SYNC {
580 >            public void checkExecutionMode() {
581 >                assertFalse(ThreadExecutor.startedCurrentThread());
582 >                assertNull(ForkJoinTask.getPool());
583 >            }
584 >            public CompletableFuture<Void> runAsync(Runnable a) {
585 >                throw new UnsupportedOperationException();
586 >            }
587 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
588 >                throw new UnsupportedOperationException();
589 >            }
590 >            public <T> CompletableFuture<Void> thenRun
591 >                (CompletableFuture<T> f, Runnable a) {
592 >                return f.thenRun(a);
593 >            }
594 >            public <T> CompletableFuture<Void> thenAccept
595 >                (CompletableFuture<T> f, Consumer<? super T> a) {
596 >                return f.thenAccept(a);
597 >            }
598 >            public <T,U> CompletableFuture<U> thenApply
599 >                (CompletableFuture<T> f, Function<? super T,U> a) {
600 >                return f.thenApply(a);
601 >            }
602 >            public <T,U> CompletableFuture<U> thenCompose
603 >                (CompletableFuture<T> f,
604 >                 Function<? super T,? extends CompletionStage<U>> a) {
605 >                return f.thenCompose(a);
606 >            }
607 >            public <T,U> CompletableFuture<U> handle
608 >                (CompletableFuture<T> f,
609 >                 BiFunction<? super T,Throwable,? extends U> a) {
610 >                return f.handle(a);
611 >            }
612 >            public <T> CompletableFuture<T> whenComplete
613 >                (CompletableFuture<T> f,
614 >                 BiConsumer<? super T,? super Throwable> a) {
615 >                return f.whenComplete(a);
616 >            }
617 >            public <T,U> CompletableFuture<Void> runAfterBoth
618 >                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
619 >                return f.runAfterBoth(g, a);
620 >            }
621 >            public <T,U> CompletableFuture<Void> thenAcceptBoth
622 >                (CompletableFuture<T> f,
623 >                 CompletionStage<? extends U> g,
624 >                 BiConsumer<? super T,? super U> a) {
625 >                return f.thenAcceptBoth(g, a);
626 >            }
627 >            public <T,U,V> CompletableFuture<V> thenCombine
628 >                (CompletableFuture<T> f,
629 >                 CompletionStage<? extends U> g,
630 >                 BiFunction<? super T,? super U,? extends V> a) {
631 >                return f.thenCombine(g, a);
632 >            }
633 >            public <T> CompletableFuture<Void> runAfterEither
634 >                (CompletableFuture<T> f,
635 >                 CompletionStage<?> g,
636 >                 java.lang.Runnable a) {
637 >                return f.runAfterEither(g, a);
638 >            }
639 >            public <T> CompletableFuture<Void> acceptEither
640 >                (CompletableFuture<T> f,
641 >                 CompletionStage<? extends T> g,
642 >                 Consumer<? super T> a) {
643 >                return f.acceptEither(g, a);
644 >            }
645 >            public <T,U> CompletableFuture<U> applyToEither
646 >                (CompletableFuture<T> f,
647 >                 CompletionStage<? extends T> g,
648 >                 Function<? super T,U> a) {
649 >                return f.applyToEither(g, a);
650 >            }
651 >        },
652  
653 <        f = new CompletableFuture<>();
654 <        f2 = new CompletableFuture<>();
655 <        f2.completeExceptionally(new CFException());
656 <        g = f.applyToEither(f2, inc);
657 <        checkCompletedWithWrappedCFException(g);
658 <    }
653 >        ASYNC {
654 >            public void checkExecutionMode() {
655 >                assertEquals(defaultExecutorIsCommonPool,
656 >                             (ForkJoinPool.commonPool() == ForkJoinTask.getPool()));
657 >            }
658 >            public CompletableFuture<Void> runAsync(Runnable a) {
659 >                return CompletableFuture.runAsync(a);
660 >            }
661 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
662 >                return CompletableFuture.supplyAsync(a);
663 >            }
664 >            public <T> CompletableFuture<Void> thenRun
665 >                (CompletableFuture<T> f, Runnable a) {
666 >                return f.thenRunAsync(a);
667 >            }
668 >            public <T> CompletableFuture<Void> thenAccept
669 >                (CompletableFuture<T> f, Consumer<? super T> a) {
670 >                return f.thenAcceptAsync(a);
671 >            }
672 >            public <T,U> CompletableFuture<U> thenApply
673 >                (CompletableFuture<T> f, Function<? super T,U> a) {
674 >                return f.thenApplyAsync(a);
675 >            }
676 >            public <T,U> CompletableFuture<U> thenCompose
677 >                (CompletableFuture<T> f,
678 >                 Function<? super T,? extends CompletionStage<U>> a) {
679 >                return f.thenComposeAsync(a);
680 >            }
681 >            public <T,U> CompletableFuture<U> handle
682 >                (CompletableFuture<T> f,
683 >                 BiFunction<? super T,Throwable,? extends U> a) {
684 >                return f.handleAsync(a);
685 >            }
686 >            public <T> CompletableFuture<T> whenComplete
687 >                (CompletableFuture<T> f,
688 >                 BiConsumer<? super T,? super Throwable> a) {
689 >                return f.whenCompleteAsync(a);
690 >            }
691 >            public <T,U> CompletableFuture<Void> runAfterBoth
692 >                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
693 >                return f.runAfterBothAsync(g, a);
694 >            }
695 >            public <T,U> CompletableFuture<Void> thenAcceptBoth
696 >                (CompletableFuture<T> f,
697 >                 CompletionStage<? extends U> g,
698 >                 BiConsumer<? super T,? super U> a) {
699 >                return f.thenAcceptBothAsync(g, a);
700 >            }
701 >            public <T,U,V> CompletableFuture<V> thenCombine
702 >                (CompletableFuture<T> f,
703 >                 CompletionStage<? extends U> g,
704 >                 BiFunction<? super T,? super U,? extends V> a) {
705 >                return f.thenCombineAsync(g, a);
706 >            }
707 >            public <T> CompletableFuture<Void> runAfterEither
708 >                (CompletableFuture<T> f,
709 >                 CompletionStage<?> g,
710 >                 java.lang.Runnable a) {
711 >                return f.runAfterEitherAsync(g, a);
712 >            }
713 >            public <T> CompletableFuture<Void> acceptEither
714 >                (CompletableFuture<T> f,
715 >                 CompletionStage<? extends T> g,
716 >                 Consumer<? super T> a) {
717 >                return f.acceptEitherAsync(g, a);
718 >            }
719 >            public <T,U> CompletableFuture<U> applyToEither
720 >                (CompletableFuture<T> f,
721 >                 CompletionStage<? extends T> g,
722 >                 Function<? super T,U> a) {
723 >                return f.applyToEitherAsync(g, a);
724 >            }
725 >        },
726  
727 <    /**
728 <     * applyToEither result completes exceptionally if action does
729 <     */
730 <    public void testApplyToEither3() {
731 <        CompletableFuture<Integer> f = new CompletableFuture<>();
732 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
733 <        FailingFunction r = new FailingFunction();
734 <        CompletableFuture<Integer> g = f.applyToEither(f2, r);
735 <        f2.complete(two);
736 <        checkCompletedWithWrappedCFException(g);
737 <    }
727 >        EXECUTOR {
728 >            public void checkExecutionMode() {
729 >                assertTrue(ThreadExecutor.startedCurrentThread());
730 >            }
731 >            public CompletableFuture<Void> runAsync(Runnable a) {
732 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
733 >            }
734 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
735 >                return CompletableFuture.supplyAsync(a, new ThreadExecutor());
736 >            }
737 >            public <T> CompletableFuture<Void> thenRun
738 >                (CompletableFuture<T> f, Runnable a) {
739 >                return f.thenRunAsync(a, new ThreadExecutor());
740 >            }
741 >            public <T> CompletableFuture<Void> thenAccept
742 >                (CompletableFuture<T> f, Consumer<? super T> a) {
743 >                return f.thenAcceptAsync(a, new ThreadExecutor());
744 >            }
745 >            public <T,U> CompletableFuture<U> thenApply
746 >                (CompletableFuture<T> f, Function<? super T,U> a) {
747 >                return f.thenApplyAsync(a, new ThreadExecutor());
748 >            }
749 >            public <T,U> CompletableFuture<U> thenCompose
750 >                (CompletableFuture<T> f,
751 >                 Function<? super T,? extends CompletionStage<U>> a) {
752 >                return f.thenComposeAsync(a, new ThreadExecutor());
753 >            }
754 >            public <T,U> CompletableFuture<U> handle
755 >                (CompletableFuture<T> f,
756 >                 BiFunction<? super T,Throwable,? extends U> a) {
757 >                return f.handleAsync(a, new ThreadExecutor());
758 >            }
759 >            public <T> CompletableFuture<T> whenComplete
760 >                (CompletableFuture<T> f,
761 >                 BiConsumer<? super T,? super Throwable> a) {
762 >                return f.whenCompleteAsync(a, new ThreadExecutor());
763 >            }
764 >            public <T,U> CompletableFuture<Void> runAfterBoth
765 >                (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
766 >                return f.runAfterBothAsync(g, a, new ThreadExecutor());
767 >            }
768 >            public <T,U> CompletableFuture<Void> thenAcceptBoth
769 >                (CompletableFuture<T> f,
770 >                 CompletionStage<? extends U> g,
771 >                 BiConsumer<? super T,? super U> a) {
772 >                return f.thenAcceptBothAsync(g, a, new ThreadExecutor());
773 >            }
774 >            public <T,U,V> CompletableFuture<V> thenCombine
775 >                (CompletableFuture<T> f,
776 >                 CompletionStage<? extends U> g,
777 >                 BiFunction<? super T,? super U,? extends V> a) {
778 >                return f.thenCombineAsync(g, a, new ThreadExecutor());
779 >            }
780 >            public <T> CompletableFuture<Void> runAfterEither
781 >                (CompletableFuture<T> f,
782 >                 CompletionStage<?> g,
783 >                 java.lang.Runnable a) {
784 >                return f.runAfterEitherAsync(g, a, new ThreadExecutor());
785 >            }
786 >            public <T> CompletableFuture<Void> acceptEither
787 >                (CompletableFuture<T> f,
788 >                 CompletionStage<? extends T> g,
789 >                 Consumer<? super T> a) {
790 >                return f.acceptEitherAsync(g, a, new ThreadExecutor());
791 >            }
792 >            public <T,U> CompletableFuture<U> applyToEither
793 >                (CompletableFuture<T> f,
794 >                 CompletionStage<? extends T> g,
795 >                 Function<? super T,U> a) {
796 >                return f.applyToEitherAsync(g, a, new ThreadExecutor());
797 >            }
798 >        };
799  
800 <    /**
801 <     * applyToEither result completes exceptionally if either source cancelled
802 <     */
803 <    public void testApplyToEither4() {
804 <        CompletableFuture<Integer> f = new CompletableFuture<>();
805 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
806 <        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
807 <        assertTrue(f.cancel(true));
808 <        checkCompletedWithWrappedCancellationException(g);
809 <        f = new CompletableFuture<>();
810 <        f2 = new CompletableFuture<>();
811 <        assertTrue(f2.cancel(true));
812 <        checkCompletedWithWrappedCancellationException(g);
813 <    }
800 >        public abstract void checkExecutionMode();
801 >        public abstract CompletableFuture<Void> runAsync(Runnable a);
802 >        public abstract <U> CompletableFuture<U> supplyAsync(Supplier<U> a);
803 >        public abstract <T> CompletableFuture<Void> thenRun
804 >            (CompletableFuture<T> f, Runnable a);
805 >        public abstract <T> CompletableFuture<Void> thenAccept
806 >            (CompletableFuture<T> f, Consumer<? super T> a);
807 >        public abstract <T,U> CompletableFuture<U> thenApply
808 >            (CompletableFuture<T> f, Function<? super T,U> a);
809 >        public abstract <T,U> CompletableFuture<U> thenCompose
810 >            (CompletableFuture<T> f,
811 >             Function<? super T,? extends CompletionStage<U>> a);
812 >        public abstract <T,U> CompletableFuture<U> handle
813 >            (CompletableFuture<T> f,
814 >             BiFunction<? super T,Throwable,? extends U> a);
815 >        public abstract <T> CompletableFuture<T> whenComplete
816 >            (CompletableFuture<T> f,
817 >             BiConsumer<? super T,? super Throwable> a);
818 >        public abstract <T,U> CompletableFuture<Void> runAfterBoth
819 >            (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
820 >        public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
821 >            (CompletableFuture<T> f,
822 >             CompletionStage<? extends U> g,
823 >             BiConsumer<? super T,? super U> a);
824 >        public abstract <T,U,V> CompletableFuture<V> thenCombine
825 >            (CompletableFuture<T> f,
826 >             CompletionStage<? extends U> g,
827 >             BiFunction<? super T,? super U,? extends V> a);
828 >        public abstract <T> CompletableFuture<Void> runAfterEither
829 >            (CompletableFuture<T> f,
830 >             CompletionStage<?> g,
831 >             java.lang.Runnable a);
832 >        public abstract <T> CompletableFuture<Void> acceptEither
833 >            (CompletableFuture<T> f,
834 >             CompletionStage<? extends T> g,
835 >             Consumer<? super T> a);
836 >        public abstract <T,U> CompletableFuture<U> applyToEither
837 >            (CompletableFuture<T> f,
838 >             CompletionStage<? extends T> g,
839 >             Function<? super T,U> a);
840 >    }
841 >
842 >    /**
843 >     * exceptionally action is not invoked when source completes
844 >     * normally, and source result is propagated
845 >     */
846 >    public void testExceptionally_normalCompletion() {
847 >        for (boolean createIncomplete : new boolean[] { true, false })
848 >        for (Integer v1 : new Integer[] { 1, null })
849 >    {
850 >        final AtomicInteger a = new AtomicInteger(0);
851 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
852 >        if (!createIncomplete) assertTrue(f.complete(v1));
853 >        final CompletableFuture<Integer> g = f.exceptionally
854 >            ((Throwable t) -> {
855 >                a.getAndIncrement();
856 >                threadFail("should not be called");
857 >                return null;            // unreached
858 >            });
859 >        if (createIncomplete) assertTrue(f.complete(v1));
860 >
861 >        checkCompletedNormally(g, v1);
862 >        checkCompletedNormally(f, v1);
863 >        assertEquals(0, a.get());
864 >    }}
865  
866      /**
867 <     * acceptEither result completes normally after normal completion
868 <     * of either source
867 >     * exceptionally action completes with function value on source
868 >     * exception
869       */
870 <    public void testAcceptEither() {
871 <        CompletableFuture<Integer> f = new CompletableFuture<>();
872 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
873 <        IncAction r = new IncAction();
874 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
875 <        f.complete(one);
876 <        checkCompletedNormally(g, null);
877 <        f2.complete(one);
878 <        checkCompletedNormally(g, null);
879 <        assertEquals(r.value, 2);
880 <
881 <        r = new IncAction();
882 <        f = new CompletableFuture<>();
883 <        f.complete(one);
884 <        f2 = new CompletableFuture<>();
885 <        g = f.acceptEither(f2, r);
886 <        checkCompletedNormally(g, null);
887 <        assertEquals(r.value, 2);
888 <    }
870 >    public void testExceptionally_exceptionalCompletion() {
871 >        for (boolean createIncomplete : new boolean[] { true, false })
872 >        for (Integer v1 : new Integer[] { 1, null })
873 >    {
874 >        final AtomicInteger a = new AtomicInteger(0);
875 >        final CFException ex = new CFException();
876 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
877 >        if (!createIncomplete) f.completeExceptionally(ex);
878 >        final CompletableFuture<Integer> g = f.exceptionally
879 >            ((Throwable t) -> {
880 >                ExecutionMode.SYNC.checkExecutionMode();
881 >                threadAssertSame(t, ex);
882 >                a.getAndIncrement();
883 >                return v1;
884 >            });
885 >        if (createIncomplete) f.completeExceptionally(ex);
886 >
887 >        checkCompletedNormally(g, v1);
888 >        assertEquals(1, a.get());
889 >    }}
890 >
891 >    /**
892 >     * If an "exceptionally action" throws an exception, it completes
893 >     * exceptionally with that exception
894 >     */
895 >    public void testExceptionally_exceptionalCompletionActionFailed() {
896 >        for (boolean createIncomplete : new boolean[] { true, false })
897 >    {
898 >        final AtomicInteger a = new AtomicInteger(0);
899 >        final CFException ex1 = new CFException();
900 >        final CFException ex2 = new CFException();
901 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
902 >        if (!createIncomplete) f.completeExceptionally(ex1);
903 >        final CompletableFuture<Integer> g = f.exceptionally
904 >            ((Throwable t) -> {
905 >                ExecutionMode.SYNC.checkExecutionMode();
906 >                threadAssertSame(t, ex1);
907 >                a.getAndIncrement();
908 >                throw ex2;
909 >            });
910 >        if (createIncomplete) f.completeExceptionally(ex1);
911 >
912 >        checkCompletedWithWrappedException(g, ex2);
913 >        checkCompletedExceptionally(f, ex1);
914 >        assertEquals(1, a.get());
915 >    }}
916  
917      /**
918 <     * acceptEither result completes exceptionally after exceptional
919 <     * completion of either source
918 >     * whenComplete action executes on normal completion, propagating
919 >     * source result.
920       */
921 <    public void testAcceptEither2() {
922 <        CompletableFuture<Integer> f = new CompletableFuture<>();
923 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
924 <        IncAction r = new IncAction();
925 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
926 <        f.completeExceptionally(new CFException());
927 <        f2.complete(one);
928 <        checkCompletedWithWrappedCFException(g);
929 <
930 <        r = new IncAction();
931 <        f = new CompletableFuture<>();
932 <        f2 = new CompletableFuture<>();
933 <        f2.completeExceptionally(new CFException());
934 <        g = f.acceptEither(f2, r);
935 <        checkCompletedWithWrappedCFException(g);
936 <    }
921 >    public void testWhenComplete_normalCompletion() {
922 >        for (ExecutionMode m : ExecutionMode.values())
923 >        for (boolean createIncomplete : new boolean[] { true, false })
924 >        for (Integer v1 : new Integer[] { 1, null })
925 >    {
926 >        final AtomicInteger a = new AtomicInteger(0);
927 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
928 >        if (!createIncomplete) assertTrue(f.complete(v1));
929 >        final CompletableFuture<Integer> g = m.whenComplete
930 >            (f,
931 >             (Integer result, Throwable t) -> {
932 >                m.checkExecutionMode();
933 >                threadAssertSame(result, v1);
934 >                threadAssertNull(t);
935 >                a.getAndIncrement();
936 >            });
937 >        if (createIncomplete) assertTrue(f.complete(v1));
938 >
939 >        checkCompletedNormally(g, v1);
940 >        checkCompletedNormally(f, v1);
941 >        assertEquals(1, a.get());
942 >    }}
943  
944      /**
945 <     * acceptEither result completes exceptionally if action does
945 >     * whenComplete action executes on exceptional completion, propagating
946 >     * source result.
947       */
948 <    public void testAcceptEither3() {
949 <        CompletableFuture<Integer> f = new CompletableFuture<>();
950 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
951 <        FailingConsumer r = new FailingConsumer();
952 <        CompletableFuture<Void> g = f.acceptEither(f2, r);
953 <        f2.complete(two);
954 <        checkCompletedWithWrappedCFException(g);
955 <    }
948 >    public void testWhenComplete_exceptionalCompletion() {
949 >        for (ExecutionMode m : ExecutionMode.values())
950 >        for (boolean createIncomplete : new boolean[] { true, false })
951 >    {
952 >        final AtomicInteger a = new AtomicInteger(0);
953 >        final CFException ex = new CFException();
954 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
955 >        if (!createIncomplete) f.completeExceptionally(ex);
956 >        final CompletableFuture<Integer> g = m.whenComplete
957 >            (f,
958 >             (Integer result, Throwable t) -> {
959 >                m.checkExecutionMode();
960 >                threadAssertNull(result);
961 >                threadAssertSame(t, ex);
962 >                a.getAndIncrement();
963 >            });
964 >        if (createIncomplete) f.completeExceptionally(ex);
965 >
966 >        checkCompletedWithWrappedException(g, ex);
967 >        checkCompletedExceptionally(f, ex);
968 >        assertEquals(1, a.get());
969 >    }}
970 >
971 >    /**
972 >     * whenComplete action executes on cancelled source, propagating
973 >     * CancellationException.
974 >     */
975 >    public void testWhenComplete_sourceCancelled() {
976 >        for (ExecutionMode m : ExecutionMode.values())
977 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
978 >        for (boolean createIncomplete : new boolean[] { true, false })
979 >    {
980 >        final AtomicInteger a = new AtomicInteger(0);
981 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
982 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
983 >        final CompletableFuture<Integer> g = m.whenComplete
984 >            (f,
985 >             (Integer result, Throwable t) -> {
986 >                m.checkExecutionMode();
987 >                threadAssertNull(result);
988 >                threadAssertTrue(t instanceof CancellationException);
989 >                a.getAndIncrement();
990 >            });
991 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
992  
1155    /**
1156     * acceptEither result completes exceptionally if either source cancelled
1157     */
1158    public void testAcceptEither4() {
1159        CompletableFuture<Integer> f = new CompletableFuture<>();
1160        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1161        IncAction r = new IncAction();
1162        CompletableFuture<Void> g = f.acceptEither(f2, r);
1163        assertTrue(f.cancel(true));
993          checkCompletedWithWrappedCancellationException(g);
994 <        f = new CompletableFuture<>();
995 <        f2 = new CompletableFuture<>();
996 <        assertTrue(f2.cancel(true));
1168 <        checkCompletedWithWrappedCancellationException(g);
1169 <    }
1170 <
1171 <    /**
1172 <     * runAfterEither result completes normally after normal completion
1173 <     * of either source
1174 <     */
1175 <    public void testRunAfterEither() {
1176 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1177 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1178 <        Noop r = new Noop();
1179 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1180 <        f.complete(one);
1181 <        checkCompletedNormally(g, null);
1182 <        f2.complete(one);
1183 <        checkCompletedNormally(g, null);
1184 <        assertTrue(r.ran);
1185 <
1186 <        r = new Noop();
1187 <        f = new CompletableFuture<>();
1188 <        f.complete(one);
1189 <        f2 = new CompletableFuture<>();
1190 <        g = f.runAfterEither(f2, r);
1191 <        checkCompletedNormally(g, null);
1192 <        assertTrue(r.ran);
1193 <    }
1194 <
1195 <    /**
1196 <     * runAfterEither result completes exceptionally after exceptional
1197 <     * completion of either source
1198 <     */
1199 <    public void testRunAfterEither2() {
1200 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1201 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1202 <        Noop r = new Noop();
1203 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1204 <        f.completeExceptionally(new CFException());
1205 <        f2.complete(one);
1206 <        checkCompletedWithWrappedCFException(g);
1207 <
1208 <        r = new Noop();
1209 <        f = new CompletableFuture<>();
1210 <        f2 = new CompletableFuture<>();
1211 <        f2.completeExceptionally(new CFException());
1212 <        g = f.runAfterEither(f2, r);
1213 <        checkCompletedWithWrappedCFException(g);
1214 <    }
1215 <
1216 <    /**
1217 <     * runAfterEither result completes exceptionally if action does
1218 <     */
1219 <    public void testRunAfterEither3() {
1220 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1221 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1222 <        FailingNoop r = new FailingNoop();
1223 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1224 <        f2.complete(two);
1225 <        checkCompletedWithWrappedCFException(g);
1226 <    }
994 >        checkCancelled(f);
995 >        assertEquals(1, a.get());
996 >    }}
997  
998      /**
999 <     * runAfterEither result completes exceptionally if either source cancelled
999 >     * If a whenComplete action throws an exception when triggered by
1000 >     * a normal completion, it completes exceptionally
1001       */
1002 <    public void testRunAfterEither4() {
1003 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1004 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1005 <        Noop r = new Noop();
1006 <        CompletableFuture<Void> g = f.runAfterEither(f2, r);
1007 <        assertTrue(f.cancel(true));
1008 <        checkCompletedWithWrappedCancellationException(g);
1009 <        f = new CompletableFuture<>();
1010 <        f2 = new CompletableFuture<>();
1011 <        assertTrue(f2.cancel(true));
1012 <        checkCompletedWithWrappedCancellationException(g);
1013 <    }
1002 >    public void testWhenComplete_sourceCompletedNormallyActionFailed() {
1003 >        for (boolean createIncomplete : new boolean[] { true, false })
1004 >        for (ExecutionMode m : ExecutionMode.values())
1005 >        for (Integer v1 : new Integer[] { 1, null })
1006 >    {
1007 >        final AtomicInteger a = new AtomicInteger(0);
1008 >        final CFException ex = new CFException();
1009 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1010 >        if (!createIncomplete) assertTrue(f.complete(v1));
1011 >        final CompletableFuture<Integer> g = m.whenComplete
1012 >            (f,
1013 >             (Integer result, Throwable t) -> {
1014 >                m.checkExecutionMode();
1015 >                threadAssertSame(result, v1);
1016 >                threadAssertNull(t);
1017 >                a.getAndIncrement();
1018 >                throw ex;
1019 >            });
1020 >        if (createIncomplete) assertTrue(f.complete(v1));
1021 >
1022 >        checkCompletedWithWrappedException(g, ex);
1023 >        checkCompletedNormally(f, v1);
1024 >        assertEquals(1, a.get());
1025 >    }}
1026  
1027      /**
1028 <     * thenCompose result completes normally after normal completion of source
1028 >     * If a whenComplete action throws an exception when triggered by
1029 >     * a source completion that also throws an exception, the source
1030 >     * exception takes precedence (unlike handle)
1031       */
1032 <    public void testThenCompose() {
1033 <        CompletableFuture<Integer> f, g;
1034 <        CompletableFutureInc r;
1035 <
1036 <        f = new CompletableFuture<>();
1037 <        g = f.thenCompose(r = new CompletableFutureInc());
1038 <        f.complete(one);
1039 <        checkCompletedNormally(g, two);
1040 <        assertTrue(r.ran);
1041 <
1042 <        f = new CompletableFuture<>();
1043 <        f.complete(one);
1044 <        g = f.thenCompose(r = new CompletableFutureInc());
1045 <        checkCompletedNormally(g, two);
1046 <        assertTrue(r.ran);
1047 <    }
1032 >    public void testWhenComplete_sourceFailedActionFailed() {
1033 >        for (boolean createIncomplete : new boolean[] { true, false })
1034 >        for (ExecutionMode m : ExecutionMode.values())
1035 >    {
1036 >        final AtomicInteger a = new AtomicInteger(0);
1037 >        final CFException ex1 = new CFException();
1038 >        final CFException ex2 = new CFException();
1039 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1040 >
1041 >        if (!createIncomplete) f.completeExceptionally(ex1);
1042 >        final CompletableFuture<Integer> g = m.whenComplete
1043 >            (f,
1044 >             (Integer result, Throwable t) -> {
1045 >                m.checkExecutionMode();
1046 >                threadAssertSame(t, ex1);
1047 >                threadAssertNull(result);
1048 >                a.getAndIncrement();
1049 >                throw ex2;
1050 >            });
1051 >        if (createIncomplete) f.completeExceptionally(ex1);
1052 >
1053 >        checkCompletedWithWrappedException(g, ex1);
1054 >        checkCompletedExceptionally(f, ex1);
1055 >        if (testImplementationDetails) {
1056 >            assertEquals(1, ex1.getSuppressed().length);
1057 >            assertSame(ex2, ex1.getSuppressed()[0]);
1058 >        }
1059 >        assertEquals(1, a.get());
1060 >    }}
1061  
1062      /**
1063 <     * thenCompose result completes exceptionally after exceptional
1063 >     * handle action completes normally with function value on normal
1064       * completion of source
1065       */
1066 <    public void testThenCompose2() {
1067 <        CompletableFuture<Integer> f, g;
1068 <        CompletableFutureInc r;
1069 <
1070 <        f = new CompletableFuture<>();
1071 <        g = f.thenCompose(r = new CompletableFutureInc());
1072 <        f.completeExceptionally(new CFException());
1073 <        checkCompletedWithWrappedCFException(g);
1074 <
1075 <        f = new CompletableFuture<>();
1076 <        f.completeExceptionally(new CFException());
1077 <        g = f.thenCompose(r = new CompletableFutureInc());
1078 <        checkCompletedWithWrappedCFException(g);
1079 <    }
1066 >    public void testHandle_normalCompletion() {
1067 >        for (ExecutionMode m : ExecutionMode.values())
1068 >        for (boolean createIncomplete : new boolean[] { true, false })
1069 >        for (Integer v1 : new Integer[] { 1, null })
1070 >    {
1071 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1072 >        final AtomicInteger a = new AtomicInteger(0);
1073 >        if (!createIncomplete) assertTrue(f.complete(v1));
1074 >        final CompletableFuture<Integer> g = m.handle
1075 >            (f,
1076 >             (Integer result, Throwable t) -> {
1077 >                m.checkExecutionMode();
1078 >                threadAssertSame(result, v1);
1079 >                threadAssertNull(t);
1080 >                a.getAndIncrement();
1081 >                return inc(v1);
1082 >            });
1083 >        if (createIncomplete) assertTrue(f.complete(v1));
1084 >
1085 >        checkCompletedNormally(g, inc(v1));
1086 >        checkCompletedNormally(f, v1);
1087 >        assertEquals(1, a.get());
1088 >    }}
1089  
1090      /**
1091 <     * thenCompose result completes exceptionally if action does
1091 >     * handle action completes normally with function value on
1092 >     * exceptional completion of source
1093       */
1094 <    public void testThenCompose3() {
1095 <        CompletableFuture<Integer> f, g;
1096 <        FailingCompletableFutureFunction r;
1097 <
1098 <        f = new CompletableFuture<>();
1099 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
1100 <        f.complete(one);
1101 <        checkCompletedWithWrappedCFException(g);
1094 >    public void testHandle_exceptionalCompletion() {
1095 >        for (ExecutionMode m : ExecutionMode.values())
1096 >        for (boolean createIncomplete : new boolean[] { true, false })
1097 >        for (Integer v1 : new Integer[] { 1, null })
1098 >    {
1099 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1100 >        final AtomicInteger a = new AtomicInteger(0);
1101 >        final CFException ex = new CFException();
1102 >        if (!createIncomplete) f.completeExceptionally(ex);
1103 >        final CompletableFuture<Integer> g = m.handle
1104 >            (f,
1105 >             (Integer result, Throwable t) -> {
1106 >                m.checkExecutionMode();
1107 >                threadAssertNull(result);
1108 >                threadAssertSame(t, ex);
1109 >                a.getAndIncrement();
1110 >                return v1;
1111 >            });
1112 >        if (createIncomplete) f.completeExceptionally(ex);
1113 >
1114 >        checkCompletedNormally(g, v1);
1115 >        checkCompletedExceptionally(f, ex);
1116 >        assertEquals(1, a.get());
1117 >    }}
1118 >
1119 >    /**
1120 >     * handle action completes normally with function value on
1121 >     * cancelled source
1122 >     */
1123 >    public void testHandle_sourceCancelled() {
1124 >        for (ExecutionMode m : ExecutionMode.values())
1125 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1126 >        for (boolean createIncomplete : new boolean[] { true, false })
1127 >        for (Integer v1 : new Integer[] { 1, null })
1128 >    {
1129 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1130 >        final AtomicInteger a = new AtomicInteger(0);
1131 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1132 >        final CompletableFuture<Integer> g = m.handle
1133 >            (f,
1134 >             (Integer result, Throwable t) -> {
1135 >                m.checkExecutionMode();
1136 >                threadAssertNull(result);
1137 >                threadAssertTrue(t instanceof CancellationException);
1138 >                a.getAndIncrement();
1139 >                return v1;
1140 >            });
1141 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1142  
1143 <        f = new CompletableFuture<>();
1144 <        f.complete(one);
1145 <        g = f.thenCompose(r = new FailingCompletableFutureFunction());
1146 <        checkCompletedWithWrappedCFException(g);
1299 <    }
1143 >        checkCompletedNormally(g, v1);
1144 >        checkCancelled(f);
1145 >        assertEquals(1, a.get());
1146 >    }}
1147  
1148      /**
1149 <     * thenCompose result completes exceptionally if source cancelled
1149 >     * If a "handle action" throws an exception when triggered by
1150 >     * a normal completion, it completes exceptionally
1151       */
1152 <    public void testThenCompose4() {
1153 <        CompletableFuture<Integer> f, g;
1154 <        CompletableFutureInc r;
1155 <
1156 <        f = new CompletableFuture<>();
1157 <        g = f.thenCompose(r = new CompletableFutureInc());
1158 <        assertTrue(f.cancel(true));
1159 <        checkCompletedWithWrappedCancellationException(g);
1160 <
1161 <        f = new CompletableFuture<>();
1162 <        assertTrue(f.cancel(true));
1163 <        g = f.thenCompose(r = new CompletableFutureInc());
1164 <        checkCompletedWithWrappedCancellationException(g);
1165 <    }
1166 <
1167 <    // asyncs
1152 >    public void testHandle_sourceCompletedNormallyActionFailed() {
1153 >        for (ExecutionMode m : ExecutionMode.values())
1154 >        for (boolean createIncomplete : new boolean[] { true, false })
1155 >        for (Integer v1 : new Integer[] { 1, null })
1156 >    {
1157 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1158 >        final AtomicInteger a = new AtomicInteger(0);
1159 >        final CFException ex = new CFException();
1160 >        if (!createIncomplete) assertTrue(f.complete(v1));
1161 >        final CompletableFuture<Integer> g = m.handle
1162 >            (f,
1163 >             (Integer result, Throwable t) -> {
1164 >                m.checkExecutionMode();
1165 >                threadAssertSame(result, v1);
1166 >                threadAssertNull(t);
1167 >                a.getAndIncrement();
1168 >                throw ex;
1169 >            });
1170 >        if (createIncomplete) assertTrue(f.complete(v1));
1171 >
1172 >        checkCompletedWithWrappedException(g, ex);
1173 >        checkCompletedNormally(f, v1);
1174 >        assertEquals(1, a.get());
1175 >    }}
1176 >
1177 >    /**
1178 >     * If a "handle action" throws an exception when triggered by
1179 >     * a source completion that also throws an exception, the action
1180 >     * exception takes precedence (unlike whenComplete)
1181 >     */
1182 >    public void testHandle_sourceFailedActionFailed() {
1183 >        for (boolean createIncomplete : new boolean[] { true, false })
1184 >        for (ExecutionMode m : ExecutionMode.values())
1185 >    {
1186 >        final AtomicInteger a = new AtomicInteger(0);
1187 >        final CFException ex1 = new CFException();
1188 >        final CFException ex2 = new CFException();
1189 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1190 >
1191 >        if (!createIncomplete) f.completeExceptionally(ex1);
1192 >        final CompletableFuture<Integer> g = m.handle
1193 >            (f,
1194 >             (Integer result, Throwable t) -> {
1195 >                m.checkExecutionMode();
1196 >                threadAssertNull(result);
1197 >                threadAssertSame(ex1, t);
1198 >                a.getAndIncrement();
1199 >                throw ex2;
1200 >            });
1201 >        if (createIncomplete) f.completeExceptionally(ex1);
1202 >
1203 >        checkCompletedWithWrappedException(g, ex2);
1204 >        checkCompletedExceptionally(f, ex1);
1205 >        assertEquals(1, a.get());
1206 >    }}
1207  
1208      /**
1209 <     * thenRunAsync result completes normally after normal completion of source
1209 >     * runAsync completes after running Runnable
1210       */
1211 <    public void testThenRunAsync() {
1212 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1213 <        Noop r = new Noop();
1214 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1215 <        f.complete(null);
1216 <        checkCompletedNormally(g, null);
1217 <
1218 <        // reordered version
1219 <        f = new CompletableFuture<>();
1220 <        f.complete(null);
1221 <        r = new Noop();
1222 <        g = f.thenRunAsync(r);
1223 <        checkCompletedNormally(g, null);
1337 <    }
1211 >    public void testRunAsync_normalCompletion() {
1212 >        ExecutionMode[] executionModes = {
1213 >            ExecutionMode.ASYNC,
1214 >            ExecutionMode.EXECUTOR,
1215 >        };
1216 >        for (ExecutionMode m : executionModes)
1217 >    {
1218 >        final Noop r = new Noop(m);
1219 >        final CompletableFuture<Void> f = m.runAsync(r);
1220 >        assertNull(f.join());
1221 >        checkCompletedNormally(f, null);
1222 >        r.assertInvoked();
1223 >    }}
1224  
1225      /**
1226 <     * thenRunAsync result completes exceptionally after exceptional
1341 <     * completion of source
1226 >     * failing runAsync completes exceptionally after running Runnable
1227       */
1228 <    public void testThenRunAsync2() {
1229 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1230 <        Noop r = new Noop();
1231 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1232 <        f.completeExceptionally(new CFException());
1228 >    public void testRunAsync_exceptionalCompletion() {
1229 >        ExecutionMode[] executionModes = {
1230 >            ExecutionMode.ASYNC,
1231 >            ExecutionMode.EXECUTOR,
1232 >        };
1233 >        for (ExecutionMode m : executionModes)
1234 >    {
1235 >        final FailingRunnable r = new FailingRunnable(m);
1236 >        final CompletableFuture<Void> f = m.runAsync(r);
1237 >        checkCompletedWithWrappedException(f, r.ex);
1238 >        r.assertInvoked();
1239 >    }}
1240 >
1241 >    @SuppressWarnings("FutureReturnValueIgnored")
1242 >    public void testRunAsync_rejectingExecutor() {
1243 >        CountingRejectingExecutor e = new CountingRejectingExecutor();
1244          try {
1245 <            g.join();
1245 >            CompletableFuture.runAsync(() -> {}, e);
1246              shouldThrow();
1247 <        } catch (CompletionException success) {}
1248 <        checkCompletedWithWrappedCFException(g);
1249 <    }
1354 <
1355 <    /**
1356 <     * thenRunAsync result completes exceptionally if action does
1357 <     */
1358 <    public void testThenRunAsync3() {
1359 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1360 <        FailingNoop r = new FailingNoop();
1361 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1362 <        f.complete(null);
1363 <        checkCompletedWithWrappedCFException(g);
1364 <    }
1247 >        } catch (Throwable t) {
1248 >            assertSame(e.ex, t);
1249 >        }
1250  
1251 <    /**
1367 <     * thenRunAsync result completes exceptionally if source cancelled
1368 <     */
1369 <    public void testThenRunAsync4() {
1370 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1371 <        Noop r = new Noop();
1372 <        CompletableFuture<Void> g = f.thenRunAsync(r);
1373 <        assertTrue(f.cancel(true));
1374 <        checkCompletedWithWrappedCancellationException(g);
1251 >        assertEquals(1, e.count.get());
1252      }
1253  
1254      /**
1255 <     * thenApplyAsync result completes normally after normal completion of source
1255 >     * supplyAsync completes with result of supplier
1256       */
1257 <    public void testThenApplyAsync() {
1258 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1259 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
1260 <        f.complete(one);
1261 <        checkCompletedNormally(g, two);
1262 <    }
1257 >    public void testSupplyAsync_normalCompletion() {
1258 >        ExecutionMode[] executionModes = {
1259 >            ExecutionMode.ASYNC,
1260 >            ExecutionMode.EXECUTOR,
1261 >        };
1262 >        for (ExecutionMode m : executionModes)
1263 >        for (Integer v1 : new Integer[] { 1, null })
1264 >    {
1265 >        final IntegerSupplier r = new IntegerSupplier(m, v1);
1266 >        final CompletableFuture<Integer> f = m.supplyAsync(r);
1267 >        assertSame(v1, f.join());
1268 >        checkCompletedNormally(f, v1);
1269 >        r.assertInvoked();
1270 >    }}
1271  
1272      /**
1273 <     * thenApplyAsync result completes exceptionally after exceptional
1389 <     * completion of source
1273 >     * Failing supplyAsync completes exceptionally
1274       */
1275 <    public void testThenApplyAsync2() {
1276 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1277 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
1278 <        f.completeExceptionally(new CFException());
1279 <        checkCompletedWithWrappedCFException(g);
1280 <    }
1275 >    public void testSupplyAsync_exceptionalCompletion() {
1276 >        ExecutionMode[] executionModes = {
1277 >            ExecutionMode.ASYNC,
1278 >            ExecutionMode.EXECUTOR,
1279 >        };
1280 >        for (ExecutionMode m : executionModes)
1281 >    {
1282 >        FailingSupplier r = new FailingSupplier(m);
1283 >        CompletableFuture<Integer> f = m.supplyAsync(r);
1284 >        checkCompletedWithWrappedException(f, r.ex);
1285 >        r.assertInvoked();
1286 >    }}
1287 >
1288 >    @SuppressWarnings("FutureReturnValueIgnored")
1289 >    public void testSupplyAsync_rejectingExecutor() {
1290 >        CountingRejectingExecutor e = new CountingRejectingExecutor();
1291 >        try {
1292 >            CompletableFuture.supplyAsync(() -> null, e);
1293 >            shouldThrow();
1294 >        } catch (Throwable t) {
1295 >            assertSame(e.ex, t);
1296 >        }
1297  
1298 <    /**
1399 <     * thenApplyAsync result completes exceptionally if action does
1400 <     */
1401 <    public void testThenApplyAsync3() {
1402 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1403 <        FailingFunction r = new FailingFunction();
1404 <        CompletableFuture<Integer> g = f.thenApplyAsync(r);
1405 <        f.complete(null);
1406 <        checkCompletedWithWrappedCFException(g);
1298 >        assertEquals(1, e.count.get());
1299      }
1300  
1301 <    /**
1410 <     * thenApplyAsync result completes exceptionally if source cancelled
1411 <     */
1412 <    public void testThenApplyAsync4() {
1413 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1414 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
1415 <        assertTrue(f.cancel(true));
1416 <        checkCompletedWithWrappedCancellationException(g);
1417 <    }
1301 >    // seq completion methods
1302  
1303      /**
1304 <     * thenAcceptAsync result completes normally after normal
1421 <     * completion of source
1304 >     * thenRun result completes normally after normal completion of source
1305       */
1306 <    public void testThenAcceptAsync() {
1307 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1308 <        IncAction r = new IncAction();
1309 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1310 <        f.complete(one);
1311 <        checkCompletedNormally(g, null);
1312 <        assertEquals(r.value, 2);
1313 <    }
1306 >    public void testThenRun_normalCompletion() {
1307 >        for (ExecutionMode m : ExecutionMode.values())
1308 >        for (Integer v1 : new Integer[] { 1, null })
1309 >    {
1310 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1311 >        final Noop[] rs = new Noop[6];
1312 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1313 >
1314 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1315 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1316 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1317 >        checkIncomplete(h0);
1318 >        checkIncomplete(h1);
1319 >        checkIncomplete(h2);
1320 >        assertTrue(f.complete(v1));
1321 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1322 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1323 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1324 >
1325 >        checkCompletedNormally(h0, null);
1326 >        checkCompletedNormally(h1, null);
1327 >        checkCompletedNormally(h2, null);
1328 >        checkCompletedNormally(h3, null);
1329 >        checkCompletedNormally(h4, null);
1330 >        checkCompletedNormally(h5, null);
1331 >        checkCompletedNormally(f, v1);
1332 >        for (Noop r : rs) r.assertInvoked();
1333 >    }}
1334  
1335      /**
1336 <     * thenAcceptAsync result completes exceptionally after exceptional
1336 >     * thenRun result completes exceptionally after exceptional
1337       * completion of source
1338       */
1339 <    public void testThenAcceptAsync2() {
1340 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1341 <        IncAction r = new IncAction();
1342 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1343 <        f.completeExceptionally(new CFException());
1344 <        checkCompletedWithWrappedCFException(g);
1345 <    }
1346 <
1347 <    /**
1348 <     * thenAcceptAsync result completes exceptionally if action does
1349 <     */
1350 <    public void testThenAcceptAsync3() {
1351 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1352 <        FailingConsumer r = new FailingConsumer();
1353 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1354 <        f.complete(null);
1355 <        checkCompletedWithWrappedCFException(g);
1356 <    }
1357 <
1358 <    /**
1359 <     * thenAcceptAsync result completes exceptionally if source cancelled
1360 <     */
1361 <    public void testThenAcceptAsync4() {
1362 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1363 <        IncAction r = new IncAction();
1364 <        CompletableFuture<Void> g = f.thenAcceptAsync(r);
1365 <        assertTrue(f.cancel(true));
1366 <        checkCompletedWithWrappedCancellationException(g);
1464 <    }
1465 <
1466 <    /**
1467 <     * thenCombineAsync result completes normally after normal
1468 <     * completion of sources
1469 <     */
1470 <    public void testThenCombineAsync() {
1471 <        CompletableFuture<Integer> f, g, h;
1472 <
1473 <        f = new CompletableFuture<>();
1474 <        g = new CompletableFuture<>();
1475 <        h = f.thenCombineAsync(g, subtract);
1476 <        f.complete(3);
1477 <        checkIncomplete(h);
1478 <        g.complete(1);
1479 <        checkCompletedNormally(h, 2);
1480 <
1481 <        f = new CompletableFuture<>();
1482 <        g = new CompletableFuture<>();
1483 <        h = f.thenCombineAsync(g, subtract);
1484 <        g.complete(1);
1485 <        checkIncomplete(h);
1486 <        f.complete(3);
1487 <        checkCompletedNormally(h, 2);
1488 <
1489 <        f = new CompletableFuture<>();
1490 <        g = new CompletableFuture<>();
1491 <        g.complete(1);
1492 <        f.complete(3);
1493 <        h = f.thenCombineAsync(g, subtract);
1494 <        checkCompletedNormally(h, 2);
1495 <    }
1339 >    public void testThenRun_exceptionalCompletion() {
1340 >        for (ExecutionMode m : ExecutionMode.values())
1341 >    {
1342 >        final CFException ex = new CFException();
1343 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1344 >        final Noop[] rs = new Noop[6];
1345 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1346 >
1347 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1348 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1349 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1350 >        checkIncomplete(h0);
1351 >        checkIncomplete(h1);
1352 >        checkIncomplete(h2);
1353 >        assertTrue(f.completeExceptionally(ex));
1354 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1355 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1356 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1357 >
1358 >        checkCompletedWithWrappedException(h0, ex);
1359 >        checkCompletedWithWrappedException(h1, ex);
1360 >        checkCompletedWithWrappedException(h2, ex);
1361 >        checkCompletedWithWrappedException(h3, ex);
1362 >        checkCompletedWithWrappedException(h4, ex);
1363 >        checkCompletedWithWrappedException(h5, ex);
1364 >        checkCompletedExceptionally(f, ex);
1365 >        for (Noop r : rs) r.assertNotInvoked();
1366 >    }}
1367  
1368      /**
1369 <     * thenCombineAsync result completes exceptionally after exceptional
1499 <     * completion of either source
1369 >     * thenRun result completes exceptionally if source cancelled
1370       */
1371 <    public void testThenCombineAsync2() {
1372 <        CompletableFuture<Integer> f, g, h;
1373 <
1374 <        f = new CompletableFuture<>();
1375 <        g = new CompletableFuture<>();
1376 <        h = f.thenCombineAsync(g, subtract);
1377 <        f.completeExceptionally(new CFException());
1378 <        checkIncomplete(h);
1379 <        g.complete(1);
1380 <        checkCompletedWithWrappedCFException(h);
1381 <
1382 <        f = new CompletableFuture<>();
1383 <        g = new CompletableFuture<>();
1384 <        h = f.thenCombineAsync(g, subtract);
1385 <        g.completeExceptionally(new CFException());
1386 <        checkIncomplete(h);
1387 <        f.complete(3);
1388 <        checkCompletedWithWrappedCFException(h);
1389 <
1390 <        f = new CompletableFuture<>();
1391 <        g = new CompletableFuture<>();
1392 <        g.completeExceptionally(new CFException());
1393 <        f.complete(3);
1394 <        h = f.thenCombineAsync(g, subtract);
1395 <        checkCompletedWithWrappedCFException(h);
1396 <    }
1371 >    public void testThenRun_sourceCancelled() {
1372 >        for (ExecutionMode m : ExecutionMode.values())
1373 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1374 >    {
1375 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1376 >        final Noop[] rs = new Noop[6];
1377 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1378 >
1379 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1380 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1381 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1382 >        checkIncomplete(h0);
1383 >        checkIncomplete(h1);
1384 >        checkIncomplete(h2);
1385 >        assertTrue(f.cancel(mayInterruptIfRunning));
1386 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1387 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1388 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1389 >
1390 >        checkCompletedWithWrappedCancellationException(h0);
1391 >        checkCompletedWithWrappedCancellationException(h1);
1392 >        checkCompletedWithWrappedCancellationException(h2);
1393 >        checkCompletedWithWrappedCancellationException(h3);
1394 >        checkCompletedWithWrappedCancellationException(h4);
1395 >        checkCompletedWithWrappedCancellationException(h5);
1396 >        checkCancelled(f);
1397 >        for (Noop r : rs) r.assertNotInvoked();
1398 >    }}
1399  
1400      /**
1401 <     * thenCombineAsync result completes exceptionally if action does
1401 >     * thenRun result completes exceptionally if action does
1402       */
1403 <    public void testThenCombineAsync3() {
1404 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1405 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1406 <        FailingBiFunction r = new FailingBiFunction();
1407 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1408 <        f.complete(one);
1409 <        checkIncomplete(g);
1410 <        assertFalse(r.ran);
1411 <        f2.complete(two);
1412 <        checkCompletedWithWrappedCFException(g);
1413 <        assertTrue(r.ran);
1414 <    }
1403 >    public void testThenRun_actionFailed() {
1404 >        for (ExecutionMode m : ExecutionMode.values())
1405 >        for (Integer v1 : new Integer[] { 1, null })
1406 >    {
1407 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1408 >        final FailingRunnable[] rs = new FailingRunnable[6];
1409 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
1410 >
1411 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1412 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1413 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1414 >        assertTrue(f.complete(v1));
1415 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1416 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1417 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1418 >
1419 >        checkCompletedWithWrappedException(h0, rs[0].ex);
1420 >        checkCompletedWithWrappedException(h1, rs[1].ex);
1421 >        checkCompletedWithWrappedException(h2, rs[2].ex);
1422 >        checkCompletedWithWrappedException(h3, rs[3].ex);
1423 >        checkCompletedWithWrappedException(h4, rs[4].ex);
1424 >        checkCompletedWithWrappedException(h5, rs[5].ex);
1425 >        checkCompletedNormally(f, v1);
1426 >    }}
1427  
1428      /**
1429 <     * thenCombineAsync result completes exceptionally if either source cancelled
1546 <     */
1547 <    public void testThenCombineAsync4() {
1548 <        CompletableFuture<Integer> f, g, h;
1549 <
1550 <        f = new CompletableFuture<>();
1551 <        g = new CompletableFuture<>();
1552 <        h = f.thenCombineAsync(g, subtract);
1553 <        assertTrue(f.cancel(true));
1554 <        checkIncomplete(h);
1555 <        g.complete(1);
1556 <        checkCompletedWithWrappedCancellationException(h);
1557 <
1558 <        f = new CompletableFuture<>();
1559 <        g = new CompletableFuture<>();
1560 <        h = f.thenCombineAsync(g, subtract);
1561 <        assertTrue(g.cancel(true));
1562 <        checkIncomplete(h);
1563 <        f.complete(3);
1564 <        checkCompletedWithWrappedCancellationException(h);
1565 <
1566 <        f = new CompletableFuture<>();
1567 <        g = new CompletableFuture<>();
1568 <        g.complete(3);
1569 <        assertTrue(f.cancel(true));
1570 <        h = f.thenCombineAsync(g, subtract);
1571 <        checkCompletedWithWrappedCancellationException(h);
1572 <
1573 <        f = new CompletableFuture<>();
1574 <        g = new CompletableFuture<>();
1575 <        f.complete(3);
1576 <        assertTrue(g.cancel(true));
1577 <        h = f.thenCombineAsync(g, subtract);
1578 <        checkCompletedWithWrappedCancellationException(h);
1579 <    }
1580 <
1581 <    /**
1582 <     * thenAcceptBothAsync result completes normally after normal
1583 <     * completion of sources
1429 >     * thenApply result completes normally after normal completion of source
1430       */
1431 <    public void testThenAcceptBothAsync() {
1432 <        CompletableFuture<Integer> f, g;
1433 <        CompletableFuture<Void> h;
1434 <        SubtractAction r;
1435 <
1436 <        f = new CompletableFuture<>();
1437 <        g = new CompletableFuture<>();
1438 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1439 <        f.complete(3);
1440 <        checkIncomplete(h);
1441 <        g.complete(1);
1442 <        checkCompletedNormally(h, null);
1443 <        assertEquals(r.value, 2);
1444 <
1445 <        f = new CompletableFuture<>();
1446 <        g = new CompletableFuture<>();
1447 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1448 <        g.complete(1);
1449 <        checkIncomplete(h);
1450 <        f.complete(3);
1451 <        checkCompletedNormally(h, null);
1452 <        assertEquals(r.value, 2);
1453 <
1608 <        f = new CompletableFuture<>();
1609 <        g = new CompletableFuture<>();
1610 <        g.complete(1);
1611 <        f.complete(3);
1612 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1613 <        checkCompletedNormally(h, null);
1614 <        assertEquals(r.value, 2);
1615 <    }
1431 >    public void testThenApply_normalCompletion() {
1432 >        for (ExecutionMode m : ExecutionMode.values())
1433 >        for (Integer v1 : new Integer[] { 1, null })
1434 >    {
1435 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1436 >        final IncFunction[] rs = new IncFunction[4];
1437 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1438 >
1439 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1440 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1441 >        checkIncomplete(h0);
1442 >        checkIncomplete(h1);
1443 >        assertTrue(f.complete(v1));
1444 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1445 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1446 >
1447 >        checkCompletedNormally(h0, inc(v1));
1448 >        checkCompletedNormally(h1, inc(v1));
1449 >        checkCompletedNormally(h2, inc(v1));
1450 >        checkCompletedNormally(h3, inc(v1));
1451 >        checkCompletedNormally(f, v1);
1452 >        for (IncFunction r : rs) r.assertValue(inc(v1));
1453 >    }}
1454  
1455      /**
1456 <     * thenAcceptBothAsync result completes exceptionally after exceptional
1456 >     * thenApply result completes exceptionally after exceptional
1457       * completion of source
1458       */
1459 <    public void testThenAcceptBothAsync2() {
1460 <        CompletableFuture<Integer> f, g;
1461 <        CompletableFuture<Void> h;
1462 <        SubtractAction r;
1463 <
1464 <        f = new CompletableFuture<>();
1465 <        g = new CompletableFuture<>();
1466 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1467 <        f.completeExceptionally(new CFException());
1468 <        checkIncomplete(h);
1469 <        g.complete(1);
1470 <        checkCompletedWithWrappedCFException(h);
1471 <
1472 <        f = new CompletableFuture<>();
1473 <        g = new CompletableFuture<>();
1474 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1475 <        g.completeExceptionally(new CFException());
1476 <        checkIncomplete(h);
1477 <        f.complete(3);
1478 <        checkCompletedWithWrappedCFException(h);
1479 <
1642 <        f = new CompletableFuture<>();
1643 <        g = new CompletableFuture<>();
1644 <        f.complete(3);
1645 <        g.completeExceptionally(new CFException());
1646 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1647 <        checkCompletedWithWrappedCFException(h);
1648 <
1649 <        f = new CompletableFuture<>();
1650 <        g = new CompletableFuture<>();
1651 <        f.completeExceptionally(new CFException());
1652 <        g.complete(3);
1653 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1654 <        checkCompletedWithWrappedCFException(h);
1655 <    }
1459 >    public void testThenApply_exceptionalCompletion() {
1460 >        for (ExecutionMode m : ExecutionMode.values())
1461 >    {
1462 >        final CFException ex = new CFException();
1463 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1464 >        final IncFunction[] rs = new IncFunction[4];
1465 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1466 >
1467 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1468 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1469 >        assertTrue(f.completeExceptionally(ex));
1470 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1471 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1472 >
1473 >        checkCompletedWithWrappedException(h0, ex);
1474 >        checkCompletedWithWrappedException(h1, ex);
1475 >        checkCompletedWithWrappedException(h2, ex);
1476 >        checkCompletedWithWrappedException(h3, ex);
1477 >        checkCompletedExceptionally(f, ex);
1478 >        for (IncFunction r : rs) r.assertNotInvoked();
1479 >    }}
1480  
1481      /**
1482 <     * thenAcceptBothAsync result completes exceptionally if action does
1482 >     * thenApply result completes exceptionally if source cancelled
1483       */
1484 <    public void testThenAcceptBothAsync3() {
1485 <        CompletableFuture<Integer> f, g;
1486 <        CompletableFuture<Void> h;
1487 <        FailingBiConsumer r;
1488 <
1489 <        f = new CompletableFuture<>();
1490 <        g = new CompletableFuture<>();
1491 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1492 <        f.complete(3);
1493 <        checkIncomplete(h);
1494 <        g.complete(1);
1495 <        checkCompletedWithWrappedCFException(h);
1496 <
1497 <        f = new CompletableFuture<>();
1498 <        g = new CompletableFuture<>();
1499 <        f.complete(3);
1500 <        g.complete(1);
1501 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1502 <        checkCompletedWithWrappedCFException(h);
1503 <    }
1484 >    public void testThenApply_sourceCancelled() {
1485 >        for (ExecutionMode m : ExecutionMode.values())
1486 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1487 >    {
1488 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1489 >        final IncFunction[] rs = new IncFunction[4];
1490 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1491 >
1492 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1493 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1494 >        assertTrue(f.cancel(mayInterruptIfRunning));
1495 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1496 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1497 >
1498 >        checkCompletedWithWrappedCancellationException(h0);
1499 >        checkCompletedWithWrappedCancellationException(h1);
1500 >        checkCompletedWithWrappedCancellationException(h2);
1501 >        checkCompletedWithWrappedCancellationException(h3);
1502 >        checkCancelled(f);
1503 >        for (IncFunction r : rs) r.assertNotInvoked();
1504 >    }}
1505  
1506      /**
1507 <     * thenAcceptBothAsync result completes exceptionally if either source cancelled
1507 >     * thenApply result completes exceptionally if action does
1508       */
1509 <    public void testThenAcceptBothAsync4() {
1510 <        CompletableFuture<Integer> f, g;
1511 <        CompletableFuture<Void> h;
1512 <        SubtractAction r;
1513 <
1514 <        f = new CompletableFuture<>();
1515 <        g = new CompletableFuture<>();
1516 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1517 <        assertTrue(f.cancel(true));
1518 <        checkIncomplete(h);
1519 <        g.complete(1);
1520 <        checkCompletedWithWrappedCancellationException(h);
1521 <
1522 <        f = new CompletableFuture<>();
1523 <        g = new CompletableFuture<>();
1524 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1525 <        assertTrue(g.cancel(true));
1526 <        checkIncomplete(h);
1527 <        f.complete(3);
1528 <        checkCompletedWithWrappedCancellationException(h);
1704 <
1705 <        f = new CompletableFuture<>();
1706 <        g = new CompletableFuture<>();
1707 <        f.complete(3);
1708 <        assertTrue(g.cancel(true));
1709 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1710 <        checkCompletedWithWrappedCancellationException(h);
1711 <
1712 <        f = new CompletableFuture<>();
1713 <        g = new CompletableFuture<>();
1714 <        assertTrue(f.cancel(true));
1715 <        g.complete(3);
1716 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1717 <        checkCompletedWithWrappedCancellationException(h);
1718 <    }
1509 >    public void testThenApply_actionFailed() {
1510 >        for (ExecutionMode m : ExecutionMode.values())
1511 >        for (Integer v1 : new Integer[] { 1, null })
1512 >    {
1513 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1514 >        final FailingFunction[] rs = new FailingFunction[4];
1515 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1516 >
1517 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1518 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1519 >        assertTrue(f.complete(v1));
1520 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1521 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1522 >
1523 >        checkCompletedWithWrappedException(h0, rs[0].ex);
1524 >        checkCompletedWithWrappedException(h1, rs[1].ex);
1525 >        checkCompletedWithWrappedException(h2, rs[2].ex);
1526 >        checkCompletedWithWrappedException(h3, rs[3].ex);
1527 >        checkCompletedNormally(f, v1);
1528 >    }}
1529  
1530      /**
1531 <     * runAfterBothAsync result completes normally after normal
1722 <     * completion of sources
1531 >     * thenAccept result completes normally after normal completion of source
1532       */
1533 <    public void testRunAfterBothAsync() {
1534 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1535 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1536 <        Noop r = new Noop();
1537 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1538 <        f.complete(one);
1539 <        checkIncomplete(g);
1540 <        f2.complete(two);
1541 <        checkCompletedNormally(g, null);
1542 <        assertTrue(r.ran);
1543 <    }
1533 >    public void testThenAccept_normalCompletion() {
1534 >        for (ExecutionMode m : ExecutionMode.values())
1535 >        for (Integer v1 : new Integer[] { 1, null })
1536 >    {
1537 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1538 >        final NoopConsumer[] rs = new NoopConsumer[4];
1539 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1540 >
1541 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1542 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1543 >        checkIncomplete(h0);
1544 >        checkIncomplete(h1);
1545 >        assertTrue(f.complete(v1));
1546 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1547 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1548 >
1549 >        checkCompletedNormally(h0, null);
1550 >        checkCompletedNormally(h1, null);
1551 >        checkCompletedNormally(h2, null);
1552 >        checkCompletedNormally(h3, null);
1553 >        checkCompletedNormally(f, v1);
1554 >        for (NoopConsumer r : rs) r.assertValue(v1);
1555 >    }}
1556  
1557      /**
1558 <     * runAfterBothAsync result completes exceptionally after exceptional
1558 >     * thenAccept result completes exceptionally after exceptional
1559       * completion of source
1560       */
1561 <    public void testRunAfterBothAsync2() {
1562 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1563 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1564 <        Noop r = new Noop();
1565 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1566 <        f.completeExceptionally(new CFException());
1567 <        f2.complete(two);
1568 <        checkCompletedWithWrappedCFException(g);
1569 <
1570 <        r = new Noop();
1571 <        f = new CompletableFuture<>();
1572 <        f2 = new CompletableFuture<>();
1573 <        g = f.runAfterBothAsync(f2, r);
1574 <        f.complete(one);
1575 <        f2.completeExceptionally(new CFException());
1576 <        checkCompletedWithWrappedCFException(g);
1577 <    }
1561 >    public void testThenAccept_exceptionalCompletion() {
1562 >        for (ExecutionMode m : ExecutionMode.values())
1563 >    {
1564 >        final CFException ex = new CFException();
1565 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1566 >        final NoopConsumer[] rs = new NoopConsumer[4];
1567 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1568 >
1569 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1570 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1571 >        assertTrue(f.completeExceptionally(ex));
1572 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1573 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1574 >
1575 >        checkCompletedWithWrappedException(h0, ex);
1576 >        checkCompletedWithWrappedException(h1, ex);
1577 >        checkCompletedWithWrappedException(h2, ex);
1578 >        checkCompletedWithWrappedException(h3, ex);
1579 >        checkCompletedExceptionally(f, ex);
1580 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1581 >    }}
1582  
1583      /**
1584 <     * runAfterBothAsync result completes exceptionally if action does
1584 >     * thenAccept result completes exceptionally if source cancelled
1585       */
1586 <    public void testRunAfterBothAsync3() {
1587 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1588 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1589 <        FailingNoop r = new FailingNoop();
1590 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1591 <        f.complete(one);
1592 <        checkIncomplete(g);
1593 <        f2.complete(two);
1594 <        checkCompletedWithWrappedCFException(g);
1595 <    }
1586 >    public void testThenAccept_sourceCancelled() {
1587 >        for (ExecutionMode m : ExecutionMode.values())
1588 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1589 >    {
1590 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1591 >        final NoopConsumer[] rs = new NoopConsumer[4];
1592 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1593 >
1594 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1595 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1596 >        assertTrue(f.cancel(mayInterruptIfRunning));
1597 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1598 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1599 >
1600 >        checkCompletedWithWrappedCancellationException(h0);
1601 >        checkCompletedWithWrappedCancellationException(h1);
1602 >        checkCompletedWithWrappedCancellationException(h2);
1603 >        checkCompletedWithWrappedCancellationException(h3);
1604 >        checkCancelled(f);
1605 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1606 >    }}
1607  
1608      /**
1609 <     * runAfterBothAsync result completes exceptionally if either source cancelled
1609 >     * thenAccept result completes exceptionally if action does
1610       */
1611 <    public void testRunAfterBothAsync4() {
1612 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1613 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1614 <        Noop r = new Noop();
1615 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1616 <        assertTrue(f.cancel(true));
1617 <        f2.complete(two);
1618 <        checkCompletedWithWrappedCancellationException(g);
1619 <
1620 <        r = new Noop();
1621 <        f = new CompletableFuture<>();
1622 <        f2 = new CompletableFuture<>();
1623 <        g = f.runAfterBothAsync(f2, r);
1624 <        f.complete(one);
1625 <        assertTrue(f2.cancel(true));
1626 <        checkCompletedWithWrappedCancellationException(g);
1627 <    }
1611 >    public void testThenAccept_actionFailed() {
1612 >        for (ExecutionMode m : ExecutionMode.values())
1613 >        for (Integer v1 : new Integer[] { 1, null })
1614 >    {
1615 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1616 >        final FailingConsumer[] rs = new FailingConsumer[4];
1617 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
1618 >
1619 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1620 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1621 >        assertTrue(f.complete(v1));
1622 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1623 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1624 >
1625 >        checkCompletedWithWrappedException(h0, rs[0].ex);
1626 >        checkCompletedWithWrappedException(h1, rs[1].ex);
1627 >        checkCompletedWithWrappedException(h2, rs[2].ex);
1628 >        checkCompletedWithWrappedException(h3, rs[3].ex);
1629 >        checkCompletedNormally(f, v1);
1630 >    }}
1631  
1632      /**
1633 <     * applyToEitherAsync result completes normally after normal
1634 <     * completion of sources
1633 >     * thenCombine result completes normally after normal completion
1634 >     * of sources
1635       */
1636 <    public void testApplyToEitherAsync() {
1637 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1638 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1639 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1640 <        f.complete(one);
1641 <        checkCompletedNormally(g, two);
1642 <
1643 <        f = new CompletableFuture<>();
1644 <        f.complete(one);
1645 <        f2 = new CompletableFuture<>();
1646 <        g = f.applyToEitherAsync(f2, inc);
1647 <        checkCompletedNormally(g, two);
1648 <    }
1636 >    public void testThenCombine_normalCompletion() {
1637 >        for (ExecutionMode m : ExecutionMode.values())
1638 >        for (boolean fFirst : new boolean[] { true, false })
1639 >        for (Integer v1 : new Integer[] { 1, null })
1640 >        for (Integer v2 : new Integer[] { 2, null })
1641 >    {
1642 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1643 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1644 >        final SubtractFunction[] rs = new SubtractFunction[6];
1645 >        for (int i = 0; i < rs.length; i++) rs[i] = new SubtractFunction(m);
1646 >
1647 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1648 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1649 >        final Integer w1 =  fFirst ? v1 : v2;
1650 >        final Integer w2 = !fFirst ? v1 : v2;
1651 >
1652 >        final CompletableFuture<Integer> h0 = m.thenCombine(f, g, rs[0]);
1653 >        final CompletableFuture<Integer> h1 = m.thenCombine(fst, fst, rs[1]);
1654 >        assertTrue(fst.complete(w1));
1655 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, rs[2]);
1656 >        final CompletableFuture<Integer> h3 = m.thenCombine(fst, fst, rs[3]);
1657 >        checkIncomplete(h0); rs[0].assertNotInvoked();
1658 >        checkIncomplete(h2); rs[2].assertNotInvoked();
1659 >        checkCompletedNormally(h1, subtract(w1, w1));
1660 >        checkCompletedNormally(h3, subtract(w1, w1));
1661 >        rs[1].assertValue(subtract(w1, w1));
1662 >        rs[3].assertValue(subtract(w1, w1));
1663 >        assertTrue(snd.complete(w2));
1664 >        final CompletableFuture<Integer> h4 = m.thenCombine(f, g, rs[4]);
1665 >
1666 >        checkCompletedNormally(h0, subtract(v1, v2));
1667 >        checkCompletedNormally(h2, subtract(v1, v2));
1668 >        checkCompletedNormally(h4, subtract(v1, v2));
1669 >        rs[0].assertValue(subtract(v1, v2));
1670 >        rs[2].assertValue(subtract(v1, v2));
1671 >        rs[4].assertValue(subtract(v1, v2));
1672 >
1673 >        checkCompletedNormally(f, v1);
1674 >        checkCompletedNormally(g, v2);
1675 >    }}
1676  
1677      /**
1678 <     * applyToEitherAsync result completes exceptionally after exceptional
1679 <     * completion of source
1678 >     * thenCombine result completes exceptionally after exceptional
1679 >     * completion of either source
1680       */
1681 <    public void testApplyToEitherAsync2() {
1682 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1683 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1684 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1685 <        f.completeExceptionally(new CFException());
1686 <        checkCompletedWithWrappedCFException(g);
1687 <
1688 <        f = new CompletableFuture<>();
1689 <        f2 = new CompletableFuture<>();
1690 <        f2.completeExceptionally(new CFException());
1691 <        g = f.applyToEitherAsync(f2, inc);
1692 <        f.complete(one);
1693 <        checkCompletedWithWrappedCFException(g);
1694 <    }
1681 >    public void testThenCombine_exceptionalCompletion() throws Throwable {
1682 >        for (ExecutionMode m : ExecutionMode.values())
1683 >        for (boolean fFirst : new boolean[] { true, false })
1684 >        for (boolean failFirst : new boolean[] { true, false })
1685 >        for (Integer v1 : new Integer[] { 1, null })
1686 >    {
1687 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1688 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1689 >        final CFException ex = new CFException();
1690 >        final SubtractFunction r1 = new SubtractFunction(m);
1691 >        final SubtractFunction r2 = new SubtractFunction(m);
1692 >        final SubtractFunction r3 = new SubtractFunction(m);
1693 >
1694 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1695 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1696 >        final Callable<Boolean> complete1 = failFirst ?
1697 >            () -> fst.completeExceptionally(ex) :
1698 >            () -> fst.complete(v1);
1699 >        final Callable<Boolean> complete2 = failFirst ?
1700 >            () -> snd.complete(v1) :
1701 >            () -> snd.completeExceptionally(ex);
1702 >
1703 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1704 >        assertTrue(complete1.call());
1705 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1706 >        checkIncomplete(h1);
1707 >        checkIncomplete(h2);
1708 >        assertTrue(complete2.call());
1709 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1710 >
1711 >        checkCompletedWithWrappedException(h1, ex);
1712 >        checkCompletedWithWrappedException(h2, ex);
1713 >        checkCompletedWithWrappedException(h3, ex);
1714 >        r1.assertNotInvoked();
1715 >        r2.assertNotInvoked();
1716 >        r3.assertNotInvoked();
1717 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1718 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1719 >    }}
1720  
1721      /**
1722 <     * applyToEitherAsync result completes exceptionally if action does
1722 >     * thenCombine result completes exceptionally if either source cancelled
1723       */
1724 <    public void testApplyToEitherAsync3() {
1725 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1726 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1727 <        FailingFunction r = new FailingFunction();
1728 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
1729 <        f.complete(one);
1730 <        checkCompletedWithWrappedCFException(g);
1731 <    }
1724 >    public void testThenCombine_sourceCancelled() throws Throwable {
1725 >        for (ExecutionMode m : ExecutionMode.values())
1726 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1727 >        for (boolean fFirst : new boolean[] { true, false })
1728 >        for (boolean failFirst : new boolean[] { true, false })
1729 >        for (Integer v1 : new Integer[] { 1, null })
1730 >    {
1731 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1732 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1733 >        final SubtractFunction r1 = new SubtractFunction(m);
1734 >        final SubtractFunction r2 = new SubtractFunction(m);
1735 >        final SubtractFunction r3 = new SubtractFunction(m);
1736 >
1737 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1738 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1739 >        final Callable<Boolean> complete1 = failFirst ?
1740 >            () -> fst.cancel(mayInterruptIfRunning) :
1741 >            () -> fst.complete(v1);
1742 >        final Callable<Boolean> complete2 = failFirst ?
1743 >            () -> snd.complete(v1) :
1744 >            () -> snd.cancel(mayInterruptIfRunning);
1745 >
1746 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1747 >        assertTrue(complete1.call());
1748 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1749 >        checkIncomplete(h1);
1750 >        checkIncomplete(h2);
1751 >        assertTrue(complete2.call());
1752 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1753 >
1754 >        checkCompletedWithWrappedCancellationException(h1);
1755 >        checkCompletedWithWrappedCancellationException(h2);
1756 >        checkCompletedWithWrappedCancellationException(h3);
1757 >        r1.assertNotInvoked();
1758 >        r2.assertNotInvoked();
1759 >        r3.assertNotInvoked();
1760 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1761 >        checkCancelled(failFirst ? fst : snd);
1762 >    }}
1763  
1764      /**
1765 <     * applyToEitherAsync result completes exceptionally if either source cancelled
1765 >     * thenCombine result completes exceptionally if action does
1766       */
1767 <    public void testApplyToEitherAsync4() {
1768 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1769 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1770 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1771 <        assertTrue(f.cancel(true));
1772 <        checkCompletedWithWrappedCancellationException(g);
1773 <
1774 <        f = new CompletableFuture<>();
1775 <        f2 = new CompletableFuture<>();
1776 <        assertTrue(f2.cancel(true));
1777 <        g = f.applyToEitherAsync(f2, inc);
1778 <        checkCompletedWithWrappedCancellationException(g);
1779 <    }
1767 >    public void testThenCombine_actionFailed() {
1768 >        for (ExecutionMode m : ExecutionMode.values())
1769 >        for (boolean fFirst : new boolean[] { true, false })
1770 >        for (Integer v1 : new Integer[] { 1, null })
1771 >        for (Integer v2 : new Integer[] { 2, null })
1772 >    {
1773 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1774 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1775 >        final FailingBiFunction r1 = new FailingBiFunction(m);
1776 >        final FailingBiFunction r2 = new FailingBiFunction(m);
1777 >        final FailingBiFunction r3 = new FailingBiFunction(m);
1778 >
1779 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1780 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1781 >        final Integer w1 =  fFirst ? v1 : v2;
1782 >        final Integer w2 = !fFirst ? v1 : v2;
1783 >
1784 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1785 >        assertTrue(fst.complete(w1));
1786 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1787 >        assertTrue(snd.complete(w2));
1788 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1789 >
1790 >        checkCompletedWithWrappedException(h1, r1.ex);
1791 >        checkCompletedWithWrappedException(h2, r2.ex);
1792 >        checkCompletedWithWrappedException(h3, r3.ex);
1793 >        r1.assertInvoked();
1794 >        r2.assertInvoked();
1795 >        r3.assertInvoked();
1796 >        checkCompletedNormally(f, v1);
1797 >        checkCompletedNormally(g, v2);
1798 >    }}
1799  
1800      /**
1801 <     * acceptEitherAsync result completes normally after normal
1801 >     * thenAcceptBoth result completes normally after normal
1802       * completion of sources
1803       */
1804 <    public void testAcceptEitherAsync() {
1805 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1806 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1807 <        IncAction r = new IncAction();
1808 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1809 <        f.complete(one);
1810 <        checkCompletedNormally(g, null);
1811 <        assertEquals(r.value, 2);
1812 <
1813 <        r = new IncAction();
1814 <        f = new CompletableFuture<>();
1815 <        f.complete(one);
1816 <        f2 = new CompletableFuture<>();
1817 <        g = f.acceptEitherAsync(f2, r);
1818 <        checkCompletedNormally(g, null);
1819 <        assertEquals(r.value, 2);
1820 <    }
1804 >    public void testThenAcceptBoth_normalCompletion() {
1805 >        for (ExecutionMode m : ExecutionMode.values())
1806 >        for (boolean fFirst : new boolean[] { true, false })
1807 >        for (Integer v1 : new Integer[] { 1, null })
1808 >        for (Integer v2 : new Integer[] { 2, null })
1809 >    {
1810 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1811 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1812 >        final SubtractAction r1 = new SubtractAction(m);
1813 >        final SubtractAction r2 = new SubtractAction(m);
1814 >        final SubtractAction r3 = new SubtractAction(m);
1815 >
1816 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1817 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1818 >        final Integer w1 =  fFirst ? v1 : v2;
1819 >        final Integer w2 = !fFirst ? v1 : v2;
1820 >
1821 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1822 >        assertTrue(fst.complete(w1));
1823 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1824 >        checkIncomplete(h1);
1825 >        checkIncomplete(h2);
1826 >        r1.assertNotInvoked();
1827 >        r2.assertNotInvoked();
1828 >        assertTrue(snd.complete(w2));
1829 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1830 >
1831 >        checkCompletedNormally(h1, null);
1832 >        checkCompletedNormally(h2, null);
1833 >        checkCompletedNormally(h3, null);
1834 >        r1.assertValue(subtract(v1, v2));
1835 >        r2.assertValue(subtract(v1, v2));
1836 >        r3.assertValue(subtract(v1, v2));
1837 >        checkCompletedNormally(f, v1);
1838 >        checkCompletedNormally(g, v2);
1839 >    }}
1840  
1841      /**
1842 <     * acceptEitherAsync result completes exceptionally after exceptional
1843 <     * completion of source
1842 >     * thenAcceptBoth result completes exceptionally after exceptional
1843 >     * completion of either source
1844       */
1845 <    public void testAcceptEitherAsync2() {
1846 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1847 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1848 <        IncAction r = new IncAction();
1849 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1850 <        f.completeExceptionally(new CFException());
1851 <        checkCompletedWithWrappedCFException(g);
1852 <
1853 <        r = new IncAction();
1854 <        f = new CompletableFuture<>();
1855 <        f2 = new CompletableFuture<>();
1856 <        f2.completeExceptionally(new CFException());
1857 <        g = f.acceptEitherAsync(f2, r);
1858 <        f.complete(one);
1859 <        checkCompletedWithWrappedCFException(g);
1860 <    }
1845 >    public void testThenAcceptBoth_exceptionalCompletion() throws Throwable {
1846 >        for (ExecutionMode m : ExecutionMode.values())
1847 >        for (boolean fFirst : new boolean[] { true, false })
1848 >        for (boolean failFirst : new boolean[] { true, false })
1849 >        for (Integer v1 : new Integer[] { 1, null })
1850 >    {
1851 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1852 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1853 >        final CFException ex = new CFException();
1854 >        final SubtractAction r1 = new SubtractAction(m);
1855 >        final SubtractAction r2 = new SubtractAction(m);
1856 >        final SubtractAction r3 = new SubtractAction(m);
1857 >
1858 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1859 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1860 >        final Callable<Boolean> complete1 = failFirst ?
1861 >            () -> fst.completeExceptionally(ex) :
1862 >            () -> fst.complete(v1);
1863 >        final Callable<Boolean> complete2 = failFirst ?
1864 >            () -> snd.complete(v1) :
1865 >            () -> snd.completeExceptionally(ex);
1866 >
1867 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1868 >        assertTrue(complete1.call());
1869 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1870 >        checkIncomplete(h1);
1871 >        checkIncomplete(h2);
1872 >        assertTrue(complete2.call());
1873 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1874 >
1875 >        checkCompletedWithWrappedException(h1, ex);
1876 >        checkCompletedWithWrappedException(h2, ex);
1877 >        checkCompletedWithWrappedException(h3, ex);
1878 >        r1.assertNotInvoked();
1879 >        r2.assertNotInvoked();
1880 >        r3.assertNotInvoked();
1881 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1882 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1883 >    }}
1884  
1885      /**
1886 <     * acceptEitherAsync result completes exceptionally if action does
1886 >     * thenAcceptBoth result completes exceptionally if either source cancelled
1887       */
1888 <    public void testAcceptEitherAsync3() {
1889 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1890 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1891 <        FailingConsumer r = new FailingConsumer();
1892 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1893 <        f.complete(one);
1894 <        checkCompletedWithWrappedCFException(g);
1895 <    }
1888 >    public void testThenAcceptBoth_sourceCancelled() throws Throwable {
1889 >        for (ExecutionMode m : ExecutionMode.values())
1890 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1891 >        for (boolean fFirst : new boolean[] { true, false })
1892 >        for (boolean failFirst : new boolean[] { true, false })
1893 >        for (Integer v1 : new Integer[] { 1, null })
1894 >    {
1895 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1896 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1897 >        final SubtractAction r1 = new SubtractAction(m);
1898 >        final SubtractAction r2 = new SubtractAction(m);
1899 >        final SubtractAction r3 = new SubtractAction(m);
1900 >
1901 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1902 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1903 >        final Callable<Boolean> complete1 = failFirst ?
1904 >            () -> fst.cancel(mayInterruptIfRunning) :
1905 >            () -> fst.complete(v1);
1906 >        final Callable<Boolean> complete2 = failFirst ?
1907 >            () -> snd.complete(v1) :
1908 >            () -> snd.cancel(mayInterruptIfRunning);
1909 >
1910 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1911 >        assertTrue(complete1.call());
1912 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1913 >        checkIncomplete(h1);
1914 >        checkIncomplete(h2);
1915 >        assertTrue(complete2.call());
1916 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1917 >
1918 >        checkCompletedWithWrappedCancellationException(h1);
1919 >        checkCompletedWithWrappedCancellationException(h2);
1920 >        checkCompletedWithWrappedCancellationException(h3);
1921 >        r1.assertNotInvoked();
1922 >        r2.assertNotInvoked();
1923 >        r3.assertNotInvoked();
1924 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1925 >        checkCancelled(failFirst ? fst : snd);
1926 >    }}
1927  
1928      /**
1929 <     * acceptEitherAsync result completes exceptionally if either
1916 <     * source cancelled
1929 >     * thenAcceptBoth result completes exceptionally if action does
1930       */
1931 <    public void testAcceptEitherAsync4() {
1932 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1933 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1934 <        IncAction r = new IncAction();
1935 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1936 <        assertTrue(f.cancel(true));
1937 <        checkCompletedWithWrappedCancellationException(g);
1938 <
1939 <        r = new IncAction();
1940 <        f = new CompletableFuture<>();
1941 <        f2 = new CompletableFuture<>();
1942 <        assertTrue(f2.cancel(true));
1943 <        g = f.acceptEitherAsync(f2, r);
1944 <        checkCompletedWithWrappedCancellationException(g);
1945 <    }
1931 >    public void testThenAcceptBoth_actionFailed() {
1932 >        for (ExecutionMode m : ExecutionMode.values())
1933 >        for (boolean fFirst : new boolean[] { true, false })
1934 >        for (Integer v1 : new Integer[] { 1, null })
1935 >        for (Integer v2 : new Integer[] { 2, null })
1936 >    {
1937 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1938 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1939 >        final FailingBiConsumer r1 = new FailingBiConsumer(m);
1940 >        final FailingBiConsumer r2 = new FailingBiConsumer(m);
1941 >        final FailingBiConsumer r3 = new FailingBiConsumer(m);
1942 >
1943 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1944 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1945 >        final Integer w1 =  fFirst ? v1 : v2;
1946 >        final Integer w2 = !fFirst ? v1 : v2;
1947 >
1948 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1949 >        assertTrue(fst.complete(w1));
1950 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1951 >        assertTrue(snd.complete(w2));
1952 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1953 >
1954 >        checkCompletedWithWrappedException(h1, r1.ex);
1955 >        checkCompletedWithWrappedException(h2, r2.ex);
1956 >        checkCompletedWithWrappedException(h3, r3.ex);
1957 >        r1.assertInvoked();
1958 >        r2.assertInvoked();
1959 >        r3.assertInvoked();
1960 >        checkCompletedNormally(f, v1);
1961 >        checkCompletedNormally(g, v2);
1962 >    }}
1963  
1964      /**
1965 <     * runAfterEitherAsync result completes normally after normal
1965 >     * runAfterBoth result completes normally after normal
1966       * completion of sources
1967       */
1968 <    public void testRunAfterEitherAsync() {
1969 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1970 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1971 <        Noop r = new Noop();
1972 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1973 <        f.complete(one);
1974 <        checkCompletedNormally(g, null);
1975 <        assertTrue(r.ran);
1976 <
1977 <        r = new Noop();
1978 <        f = new CompletableFuture<>();
1979 <        f.complete(one);
1980 <        f2 = new CompletableFuture<>();
1981 <        g = f.runAfterEitherAsync(f2, r);
1982 <        checkCompletedNormally(g, null);
1983 <        assertTrue(r.ran);
1984 <    }
1985 <
1986 <    /**
1987 <     * runAfterEitherAsync result completes exceptionally after exceptional
1988 <     * completion of source
1989 <     */
1990 <    public void testRunAfterEitherAsync2() {
1991 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1992 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1993 <        Noop r = new Noop();
1994 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1995 <        f.completeExceptionally(new CFException());
1996 <        checkCompletedWithWrappedCFException(g);
1997 <
1998 <        r = new Noop();
1999 <        f = new CompletableFuture<>();
2000 <        f2 = new CompletableFuture<>();
2001 <        f2.completeExceptionally(new CFException());
2002 <        g = f.runAfterEitherAsync(f2, r);
2003 <        f.complete(one);
1974 <        checkCompletedWithWrappedCFException(g);
1975 <    }
1968 >    public void testRunAfterBoth_normalCompletion() {
1969 >        for (ExecutionMode m : ExecutionMode.values())
1970 >        for (boolean fFirst : new boolean[] { true, false })
1971 >        for (Integer v1 : new Integer[] { 1, null })
1972 >        for (Integer v2 : new Integer[] { 2, null })
1973 >    {
1974 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1975 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
1976 >        final Noop r1 = new Noop(m);
1977 >        final Noop r2 = new Noop(m);
1978 >        final Noop r3 = new Noop(m);
1979 >
1980 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1981 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1982 >        final Integer w1 =  fFirst ? v1 : v2;
1983 >        final Integer w2 = !fFirst ? v1 : v2;
1984 >
1985 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1986 >        assertTrue(fst.complete(w1));
1987 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1988 >        checkIncomplete(h1);
1989 >        checkIncomplete(h2);
1990 >        r1.assertNotInvoked();
1991 >        r2.assertNotInvoked();
1992 >        assertTrue(snd.complete(w2));
1993 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
1994 >
1995 >        checkCompletedNormally(h1, null);
1996 >        checkCompletedNormally(h2, null);
1997 >        checkCompletedNormally(h3, null);
1998 >        r1.assertInvoked();
1999 >        r2.assertInvoked();
2000 >        r3.assertInvoked();
2001 >        checkCompletedNormally(f, v1);
2002 >        checkCompletedNormally(g, v2);
2003 >    }}
2004  
2005      /**
2006 <     * runAfterEitherAsync result completes exceptionally if action does
2007 <     */
1980 <    public void testRunAfterEitherAsync3() {
1981 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1982 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1983 <        FailingNoop r = new FailingNoop();
1984 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1985 <        f.complete(one);
1986 <        checkCompletedWithWrappedCFException(g);
1987 <    }
1988 <
1989 <    /**
1990 <     * runAfterEitherAsync result completes exceptionally if either
1991 <     * source cancelled
1992 <     */
1993 <    public void testRunAfterEitherAsync4() {
1994 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1995 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
1996 <        Noop r = new Noop();
1997 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1998 <        assertTrue(f.cancel(true));
1999 <        checkCompletedWithWrappedCancellationException(g);
2000 <
2001 <        r = new Noop();
2002 <        f = new CompletableFuture<>();
2003 <        f2 = new CompletableFuture<>();
2004 <        assertTrue(f2.cancel(true));
2005 <        g = f.runAfterEitherAsync(f2, r);
2006 <        checkCompletedWithWrappedCancellationException(g);
2007 <    }
2008 <
2009 <    /**
2010 <     * thenComposeAsync result completes normally after normal
2011 <     * completion of source
2012 <     */
2013 <    public void testThenComposeAsync() {
2014 <        CompletableFuture<Integer> f, g;
2015 <        CompletableFutureInc r;
2016 <
2017 <        f = new CompletableFuture<>();
2018 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2019 <        f.complete(one);
2020 <        checkCompletedNormally(g, two);
2021 <
2022 <        f = new CompletableFuture<>();
2023 <        f.complete(one);
2024 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2025 <        checkCompletedNormally(g, two);
2026 <    }
2027 <
2028 <    /**
2029 <     * thenComposeAsync result completes exceptionally after
2030 <     * exceptional completion of source
2006 >     * runAfterBoth result completes exceptionally after exceptional
2007 >     * completion of either source
2008       */
2009 <    public void testThenComposeAsync2() {
2010 <        CompletableFuture<Integer> f, g;
2011 <        CompletableFutureInc r;
2012 <
2013 <        f = new CompletableFuture<>();
2014 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2015 <        f.completeExceptionally(new CFException());
2016 <        checkCompletedWithWrappedCFException(g);
2017 <        assertFalse(r.ran);
2018 <
2019 <        f = new CompletableFuture<>();
2020 <        f.completeExceptionally(new CFException());
2021 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2022 <        checkCompletedWithWrappedCFException(g);
2023 <        assertFalse(r.ran);
2024 <    }
2009 >    public void testRunAfterBoth_exceptionalCompletion() throws Throwable {
2010 >        for (ExecutionMode m : ExecutionMode.values())
2011 >        for (boolean fFirst : new boolean[] { true, false })
2012 >        for (boolean failFirst : new boolean[] { true, false })
2013 >        for (Integer v1 : new Integer[] { 1, null })
2014 >    {
2015 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2016 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2017 >        final CFException ex = new CFException();
2018 >        final Noop r1 = new Noop(m);
2019 >        final Noop r2 = new Noop(m);
2020 >        final Noop r3 = new Noop(m);
2021 >
2022 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2023 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2024 >        final Callable<Boolean> complete1 = failFirst ?
2025 >            () -> fst.completeExceptionally(ex) :
2026 >            () -> fst.complete(v1);
2027 >        final Callable<Boolean> complete2 = failFirst ?
2028 >            () -> snd.complete(v1) :
2029 >            () -> snd.completeExceptionally(ex);
2030 >
2031 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2032 >        assertTrue(complete1.call());
2033 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2034 >        checkIncomplete(h1);
2035 >        checkIncomplete(h2);
2036 >        assertTrue(complete2.call());
2037 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2038 >
2039 >        checkCompletedWithWrappedException(h1, ex);
2040 >        checkCompletedWithWrappedException(h2, ex);
2041 >        checkCompletedWithWrappedException(h3, ex);
2042 >        r1.assertNotInvoked();
2043 >        r2.assertNotInvoked();
2044 >        r3.assertNotInvoked();
2045 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2046 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
2047 >    }}
2048  
2049      /**
2050 <     * thenComposeAsync result completes exceptionally if action does
2050 >     * runAfterBoth result completes exceptionally if either source cancelled
2051       */
2052 <    public void testThenComposeAsync3() {
2053 <        CompletableFuture<Integer> f, g;
2054 <        FailingCompletableFutureFunction r;
2055 <
2056 <        f = new CompletableFuture<>();
2057 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2058 <        f.complete(one);
2059 <        checkCompletedWithWrappedCFException(g);
2060 <
2061 <        f = new CompletableFuture<>();
2062 <        f.complete(one);
2063 <        g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2064 <        checkCompletedWithWrappedCFException(g);
2065 <    }
2052 >    public void testRunAfterBoth_sourceCancelled() throws Throwable {
2053 >        for (ExecutionMode m : ExecutionMode.values())
2054 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2055 >        for (boolean fFirst : new boolean[] { true, false })
2056 >        for (boolean failFirst : new boolean[] { true, false })
2057 >        for (Integer v1 : new Integer[] { 1, null })
2058 >    {
2059 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2060 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2061 >        final Noop r1 = new Noop(m);
2062 >        final Noop r2 = new Noop(m);
2063 >        final Noop r3 = new Noop(m);
2064 >
2065 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2066 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2067 >        final Callable<Boolean> complete1 = failFirst ?
2068 >            () -> fst.cancel(mayInterruptIfRunning) :
2069 >            () -> fst.complete(v1);
2070 >        final Callable<Boolean> complete2 = failFirst ?
2071 >            () -> snd.complete(v1) :
2072 >            () -> snd.cancel(mayInterruptIfRunning);
2073 >
2074 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2075 >        assertTrue(complete1.call());
2076 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2077 >        checkIncomplete(h1);
2078 >        checkIncomplete(h2);
2079 >        assertTrue(complete2.call());
2080 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2081 >
2082 >        checkCompletedWithWrappedCancellationException(h1);
2083 >        checkCompletedWithWrappedCancellationException(h2);
2084 >        checkCompletedWithWrappedCancellationException(h3);
2085 >        r1.assertNotInvoked();
2086 >        r2.assertNotInvoked();
2087 >        r3.assertNotInvoked();
2088 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2089 >        checkCancelled(failFirst ? fst : snd);
2090 >    }}
2091  
2092      /**
2093 <     * thenComposeAsync result completes exceptionally if source cancelled
2093 >     * runAfterBoth result completes exceptionally if action does
2094       */
2095 <    public void testThenComposeAsync4() {
2096 <        CompletableFuture<Integer> f, g;
2097 <        CompletableFutureInc r;
2098 <
2099 <        f = new CompletableFuture<>();
2100 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2101 <        assertTrue(f.cancel(true));
2102 <        checkCompletedWithWrappedCancellationException(g);
2103 <
2104 <        f = new CompletableFuture<>();
2105 <        assertTrue(f.cancel(true));
2106 <        g = f.thenComposeAsync(r = new CompletableFutureInc());
2107 <        checkCompletedWithWrappedCancellationException(g);
2108 <    }
2109 <
2110 <    // async with explicit executors
2095 >    public void testRunAfterBoth_actionFailed() {
2096 >        for (ExecutionMode m : ExecutionMode.values())
2097 >        for (boolean fFirst : new boolean[] { true, false })
2098 >        for (Integer v1 : new Integer[] { 1, null })
2099 >        for (Integer v2 : new Integer[] { 2, null })
2100 >    {
2101 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2102 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2103 >        final FailingRunnable r1 = new FailingRunnable(m);
2104 >        final FailingRunnable r2 = new FailingRunnable(m);
2105 >        final FailingRunnable r3 = new FailingRunnable(m);
2106 >
2107 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2108 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2109 >        final Integer w1 =  fFirst ? v1 : v2;
2110 >        final Integer w2 = !fFirst ? v1 : v2;
2111 >
2112 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2113 >        assertTrue(fst.complete(w1));
2114 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2115 >        assertTrue(snd.complete(w2));
2116 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2117 >
2118 >        checkCompletedWithWrappedException(h1, r1.ex);
2119 >        checkCompletedWithWrappedException(h2, r2.ex);
2120 >        checkCompletedWithWrappedException(h3, r3.ex);
2121 >        r1.assertInvoked();
2122 >        r2.assertInvoked();
2123 >        r3.assertInvoked();
2124 >        checkCompletedNormally(f, v1);
2125 >        checkCompletedNormally(g, v2);
2126 >    }}
2127  
2128      /**
2129 <     * thenRunAsync result completes normally after normal completion of source
2129 >     * applyToEither result completes normally after normal completion
2130 >     * of either source
2131       */
2132 <    public void testThenRunAsyncE() {
2133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2134 <        Noop r = new Noop();
2135 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2136 <        f.complete(null);
2137 <        checkCompletedNormally(g, null);
2138 <
2139 <        // reordered version
2140 <        f = new CompletableFuture<>();
2141 <        f.complete(null);
2142 <        r = new Noop();
2143 <        g = f.thenRunAsync(r, new ThreadExecutor());
2144 <        checkCompletedNormally(g, null);
2145 <    }
2132 >    public void testApplyToEither_normalCompletion() {
2133 >        for (ExecutionMode m : ExecutionMode.values())
2134 >        for (Integer v1 : new Integer[] { 1, null })
2135 >        for (Integer v2 : new Integer[] { 2, null })
2136 >    {
2137 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2138 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2139 >        final IncFunction[] rs = new IncFunction[6];
2140 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2141 >
2142 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2143 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2144 >        checkIncomplete(h0);
2145 >        checkIncomplete(h1);
2146 >        rs[0].assertNotInvoked();
2147 >        rs[1].assertNotInvoked();
2148 >        f.complete(v1);
2149 >        checkCompletedNormally(h0, inc(v1));
2150 >        checkCompletedNormally(h1, inc(v1));
2151 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2152 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2153 >        checkCompletedNormally(h2, inc(v1));
2154 >        checkCompletedNormally(h3, inc(v1));
2155 >        g.complete(v2);
2156 >
2157 >        // unspecified behavior - both source completions available
2158 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2159 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2160 >        rs[4].assertValue(h4.join());
2161 >        rs[5].assertValue(h5.join());
2162 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
2163 >                   Objects.equals(inc(v2), h4.join()));
2164 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
2165 >                   Objects.equals(inc(v2), h5.join()));
2166 >
2167 >        checkCompletedNormally(f, v1);
2168 >        checkCompletedNormally(g, v2);
2169 >        checkCompletedNormally(h0, inc(v1));
2170 >        checkCompletedNormally(h1, inc(v1));
2171 >        checkCompletedNormally(h2, inc(v1));
2172 >        checkCompletedNormally(h3, inc(v1));
2173 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
2174 >    }}
2175  
2176      /**
2177 <     * thenRunAsync result completes exceptionally after exceptional
2178 <     * completion of source
2177 >     * applyToEither result completes exceptionally after exceptional
2178 >     * completion of either source
2179       */
2180 <    public void testThenRunAsync2E() {
2181 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2182 <        Noop r = new Noop();
2183 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2184 <        f.completeExceptionally(new CFException());
2180 >    public void testApplyToEither_exceptionalCompletion() {
2181 >        for (ExecutionMode m : ExecutionMode.values())
2182 >        for (Integer v1 : new Integer[] { 1, null })
2183 >    {
2184 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2185 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2186 >        final CFException ex = new CFException();
2187 >        final IncFunction[] rs = new IncFunction[6];
2188 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2189 >
2190 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2191 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2192 >        checkIncomplete(h0);
2193 >        checkIncomplete(h1);
2194 >        rs[0].assertNotInvoked();
2195 >        rs[1].assertNotInvoked();
2196 >        f.completeExceptionally(ex);
2197 >        checkCompletedWithWrappedException(h0, ex);
2198 >        checkCompletedWithWrappedException(h1, ex);
2199 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2200 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2201 >        checkCompletedWithWrappedException(h2, ex);
2202 >        checkCompletedWithWrappedException(h3, ex);
2203 >        g.complete(v1);
2204 >
2205 >        // unspecified behavior - both source completions available
2206 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2207 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2208          try {
2209 <            g.join();
2210 <            shouldThrow();
2211 <        } catch (CompletionException success) {}
2212 <        checkCompletedWithWrappedCFException(g);
2213 <    }
2214 <
2215 <    /**
2216 <     * thenRunAsync result completes exceptionally if action does
2217 <     */
2218 <    public void testThenRunAsync3E() {
2219 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2220 <        FailingNoop r = new FailingNoop();
2221 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2128 <        f.complete(null);
2129 <        checkCompletedWithWrappedCFException(g);
2130 <    }
2131 <
2132 <    /**
2133 <     * thenRunAsync result completes exceptionally if source cancelled
2134 <     */
2135 <    public void testThenRunAsync4E() {
2136 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2137 <        Noop r = new Noop();
2138 <        CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2139 <        assertTrue(f.cancel(true));
2140 <        checkCompletedWithWrappedCancellationException(g);
2141 <    }
2209 >            assertEquals(inc(v1), h4.join());
2210 >            rs[4].assertValue(inc(v1));
2211 >        } catch (CompletionException ok) {
2212 >            checkCompletedWithWrappedException(h4, ex);
2213 >            rs[4].assertNotInvoked();
2214 >        }
2215 >        try {
2216 >            assertEquals(inc(v1), h5.join());
2217 >            rs[5].assertValue(inc(v1));
2218 >        } catch (CompletionException ok) {
2219 >            checkCompletedWithWrappedException(h5, ex);
2220 >            rs[5].assertNotInvoked();
2221 >        }
2222  
2223 <    /**
2224 <     * thenApplyAsync result completes normally after normal completion of source
2225 <     */
2226 <    public void testThenApplyAsyncE() {
2227 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2228 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2229 <        f.complete(one);
2230 <        checkCompletedNormally(g, two);
2231 <    }
2223 >        checkCompletedExceptionally(f, ex);
2224 >        checkCompletedNormally(g, v1);
2225 >        checkCompletedWithWrappedException(h0, ex);
2226 >        checkCompletedWithWrappedException(h1, ex);
2227 >        checkCompletedWithWrappedException(h2, ex);
2228 >        checkCompletedWithWrappedException(h3, ex);
2229 >        checkCompletedWithWrappedException(h4, ex);
2230 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2231 >    }}
2232 >
2233 >    public void testApplyToEither_exceptionalCompletion2() {
2234 >        for (ExecutionMode m : ExecutionMode.values())
2235 >        for (boolean fFirst : new boolean[] { true, false })
2236 >        for (Integer v1 : new Integer[] { 1, null })
2237 >    {
2238 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2239 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2240 >        final CFException ex = new CFException();
2241 >        final IncFunction[] rs = new IncFunction[6];
2242 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2243 >
2244 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2245 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2246 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2247 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2248 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2249 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2250  
2251 <    /**
2252 <     * thenApplyAsync result completes exceptionally after exceptional
2253 <     * completion of source
2254 <     */
2255 <    public void testThenApplyAsync2E() {
2256 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2257 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2258 <        f.completeExceptionally(new CFException());
2259 <        checkCompletedWithWrappedCFException(g);
2260 <    }
2251 >        // unspecified behavior - both source completions available
2252 >        try {
2253 >            assertEquals(inc(v1), h0.join());
2254 >            rs[0].assertValue(inc(v1));
2255 >        } catch (CompletionException ok) {
2256 >            checkCompletedWithWrappedException(h0, ex);
2257 >            rs[0].assertNotInvoked();
2258 >        }
2259 >        try {
2260 >            assertEquals(inc(v1), h1.join());
2261 >            rs[1].assertValue(inc(v1));
2262 >        } catch (CompletionException ok) {
2263 >            checkCompletedWithWrappedException(h1, ex);
2264 >            rs[1].assertNotInvoked();
2265 >        }
2266 >        try {
2267 >            assertEquals(inc(v1), h2.join());
2268 >            rs[2].assertValue(inc(v1));
2269 >        } catch (CompletionException ok) {
2270 >            checkCompletedWithWrappedException(h2, ex);
2271 >            rs[2].assertNotInvoked();
2272 >        }
2273 >        try {
2274 >            assertEquals(inc(v1), h3.join());
2275 >            rs[3].assertValue(inc(v1));
2276 >        } catch (CompletionException ok) {
2277 >            checkCompletedWithWrappedException(h3, ex);
2278 >            rs[3].assertNotInvoked();
2279 >        }
2280  
2281 <    /**
2282 <     * thenApplyAsync result completes exceptionally if action does
2283 <     */
2167 <    public void testThenApplyAsync3E() {
2168 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2169 <        FailingFunction r = new FailingFunction();
2170 <        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2171 <        f.complete(null);
2172 <        checkCompletedWithWrappedCFException(g);
2173 <    }
2281 >        checkCompletedNormally(f, v1);
2282 >        checkCompletedExceptionally(g, ex);
2283 >    }}
2284  
2285      /**
2286 <     * thenApplyAsync result completes exceptionally if source cancelled
2286 >     * applyToEither result completes exceptionally if either source cancelled
2287       */
2288 <    public void testThenApplyAsync4E() {
2289 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2290 <        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2291 <        assertTrue(f.cancel(true));
2292 <        checkCompletedWithWrappedCancellationException(g);
2293 <    }
2288 >    public void testApplyToEither_sourceCancelled() {
2289 >        for (ExecutionMode m : ExecutionMode.values())
2290 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2291 >        for (Integer v1 : new Integer[] { 1, null })
2292 >    {
2293 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2294 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2295 >        final IncFunction[] rs = new IncFunction[6];
2296 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2297 >
2298 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2299 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2300 >        checkIncomplete(h0);
2301 >        checkIncomplete(h1);
2302 >        rs[0].assertNotInvoked();
2303 >        rs[1].assertNotInvoked();
2304 >        f.cancel(mayInterruptIfRunning);
2305 >        checkCompletedWithWrappedCancellationException(h0);
2306 >        checkCompletedWithWrappedCancellationException(h1);
2307 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2308 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2309 >        checkCompletedWithWrappedCancellationException(h2);
2310 >        checkCompletedWithWrappedCancellationException(h3);
2311 >        g.complete(v1);
2312 >
2313 >        // unspecified behavior - both source completions available
2314 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2315 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2316 >        try {
2317 >            assertEquals(inc(v1), h4.join());
2318 >            rs[4].assertValue(inc(v1));
2319 >        } catch (CompletionException ok) {
2320 >            checkCompletedWithWrappedCancellationException(h4);
2321 >            rs[4].assertNotInvoked();
2322 >        }
2323 >        try {
2324 >            assertEquals(inc(v1), h5.join());
2325 >            rs[5].assertValue(inc(v1));
2326 >        } catch (CompletionException ok) {
2327 >            checkCompletedWithWrappedCancellationException(h5);
2328 >            rs[5].assertNotInvoked();
2329 >        }
2330  
2331 <    /**
2332 <     * thenAcceptAsync result completes normally after normal
2333 <     * completion of source
2334 <     */
2335 <    public void testThenAcceptAsyncE() {
2336 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2337 <        IncAction r = new IncAction();
2338 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2339 <        f.complete(one);
2340 <        checkCompletedNormally(g, null);
2341 <        assertEquals(r.value, 2);
2342 <    }
2331 >        checkCancelled(f);
2332 >        checkCompletedNormally(g, v1);
2333 >        checkCompletedWithWrappedCancellationException(h0);
2334 >        checkCompletedWithWrappedCancellationException(h1);
2335 >        checkCompletedWithWrappedCancellationException(h2);
2336 >        checkCompletedWithWrappedCancellationException(h3);
2337 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2338 >    }}
2339 >
2340 >    public void testApplyToEither_sourceCancelled2() {
2341 >        for (ExecutionMode m : ExecutionMode.values())
2342 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2343 >        for (boolean fFirst : new boolean[] { true, false })
2344 >        for (Integer v1 : new Integer[] { 1, null })
2345 >    {
2346 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2347 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2348 >        final IncFunction[] rs = new IncFunction[6];
2349 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2350 >
2351 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2352 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2353 >        assertTrue(fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2354 >        assertTrue(!fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2355 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2356 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2357  
2358 <    /**
2359 <     * thenAcceptAsync result completes exceptionally after exceptional
2360 <     * completion of source
2361 <     */
2362 <    public void testThenAcceptAsync2E() {
2363 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2364 <        IncAction r = new IncAction();
2365 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2366 <        f.completeExceptionally(new CFException());
2367 <        checkCompletedWithWrappedCFException(g);
2368 <    }
2358 >        // unspecified behavior - both source completions available
2359 >        try {
2360 >            assertEquals(inc(v1), h0.join());
2361 >            rs[0].assertValue(inc(v1));
2362 >        } catch (CompletionException ok) {
2363 >            checkCompletedWithWrappedCancellationException(h0);
2364 >            rs[0].assertNotInvoked();
2365 >        }
2366 >        try {
2367 >            assertEquals(inc(v1), h1.join());
2368 >            rs[1].assertValue(inc(v1));
2369 >        } catch (CompletionException ok) {
2370 >            checkCompletedWithWrappedCancellationException(h1);
2371 >            rs[1].assertNotInvoked();
2372 >        }
2373 >        try {
2374 >            assertEquals(inc(v1), h2.join());
2375 >            rs[2].assertValue(inc(v1));
2376 >        } catch (CompletionException ok) {
2377 >            checkCompletedWithWrappedCancellationException(h2);
2378 >            rs[2].assertNotInvoked();
2379 >        }
2380 >        try {
2381 >            assertEquals(inc(v1), h3.join());
2382 >            rs[3].assertValue(inc(v1));
2383 >        } catch (CompletionException ok) {
2384 >            checkCompletedWithWrappedCancellationException(h3);
2385 >            rs[3].assertNotInvoked();
2386 >        }
2387  
2388 <    /**
2389 <     * thenAcceptAsync result completes exceptionally if action does
2390 <     */
2213 <    public void testThenAcceptAsync3E() {
2214 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2215 <        FailingConsumer r = new FailingConsumer();
2216 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2217 <        f.complete(null);
2218 <        checkCompletedWithWrappedCFException(g);
2219 <    }
2388 >        checkCompletedNormally(f, v1);
2389 >        checkCancelled(g);
2390 >    }}
2391  
2392      /**
2393 <     * thenAcceptAsync result completes exceptionally if source cancelled
2393 >     * applyToEither result completes exceptionally if action does
2394       */
2395 <    public void testThenAcceptAsync4E() {
2396 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2397 <        IncAction r = new IncAction();
2398 <        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2399 <        assertTrue(f.cancel(true));
2400 <        checkCompletedWithWrappedCancellationException(g);
2401 <    }
2395 >    public void testApplyToEither_actionFailed() {
2396 >        for (ExecutionMode m : ExecutionMode.values())
2397 >        for (Integer v1 : new Integer[] { 1, null })
2398 >        for (Integer v2 : new Integer[] { 2, null })
2399 >    {
2400 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2401 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2402 >        final FailingFunction[] rs = new FailingFunction[6];
2403 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
2404 >
2405 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2406 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2407 >        f.complete(v1);
2408 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2409 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2410 >        checkCompletedWithWrappedException(h0, rs[0].ex);
2411 >        checkCompletedWithWrappedException(h1, rs[1].ex);
2412 >        checkCompletedWithWrappedException(h2, rs[2].ex);
2413 >        checkCompletedWithWrappedException(h3, rs[3].ex);
2414 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2415 >
2416 >        g.complete(v2);
2417 >
2418 >        // unspecified behavior - both source completions available
2419 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2420 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2421 >
2422 >        checkCompletedWithWrappedException(h4, rs[4].ex);
2423 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2424 >                   Objects.equals(v2, rs[4].value));
2425 >        checkCompletedWithWrappedException(h5, rs[5].ex);
2426 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2427 >                   Objects.equals(v2, rs[5].value));
2428 >
2429 >        checkCompletedNormally(f, v1);
2430 >        checkCompletedNormally(g, v2);
2431 >    }}
2432  
2433      /**
2434 <     * thenCombineAsync result completes normally after normal
2435 <     * completion of sources
2434 >     * acceptEither result completes normally after normal completion
2435 >     * of either source
2436       */
2437 <    public void testThenCombineAsyncE() {
2438 <        CompletableFuture<Integer> f, g, h;
2439 <        ThreadExecutor e = new ThreadExecutor();
2440 <        int count = 0;
2441 <
2442 <        f = new CompletableFuture<>();
2443 <        g = new CompletableFuture<>();
2444 <        h = f.thenCombineAsync(g, subtract, e);
2445 <        f.complete(3);
2446 <        checkIncomplete(h);
2447 <        g.complete(1);
2448 <        checkCompletedNormally(h, 2);
2449 <        assertEquals(++count, e.count.get());
2450 <
2451 <        f = new CompletableFuture<>();
2452 <        g = new CompletableFuture<>();
2453 <        h = f.thenCombineAsync(g, subtract, e);
2454 <        g.complete(1);
2455 <        checkIncomplete(h);
2456 <        f.complete(3);
2457 <        checkCompletedNormally(h, 2);
2458 <        assertEquals(++count, e.count.get());
2459 <
2460 <        f = new CompletableFuture<>();
2461 <        g = new CompletableFuture<>();
2462 <        g.complete(1);
2463 <        f.complete(3);
2464 <        h = f.thenCombineAsync(g, subtract, e);
2465 <        checkCompletedNormally(h, 2);
2466 <        assertEquals(++count, e.count.get());
2467 <    }
2437 >    public void testAcceptEither_normalCompletion() {
2438 >        for (ExecutionMode m : ExecutionMode.values())
2439 >        for (Integer v1 : new Integer[] { 1, null })
2440 >        for (Integer v2 : new Integer[] { 2, null })
2441 >    {
2442 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2443 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2444 >        final NoopConsumer[] rs = new NoopConsumer[6];
2445 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2446 >
2447 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2448 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2449 >        checkIncomplete(h0);
2450 >        checkIncomplete(h1);
2451 >        rs[0].assertNotInvoked();
2452 >        rs[1].assertNotInvoked();
2453 >        f.complete(v1);
2454 >        checkCompletedNormally(h0, null);
2455 >        checkCompletedNormally(h1, null);
2456 >        rs[0].assertValue(v1);
2457 >        rs[1].assertValue(v1);
2458 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2459 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2460 >        checkCompletedNormally(h2, null);
2461 >        checkCompletedNormally(h3, null);
2462 >        rs[2].assertValue(v1);
2463 >        rs[3].assertValue(v1);
2464 >        g.complete(v2);
2465 >
2466 >        // unspecified behavior - both source completions available
2467 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2468 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2469 >        checkCompletedNormally(h4, null);
2470 >        checkCompletedNormally(h5, null);
2471 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2472 >                   Objects.equals(v2, rs[4].value));
2473 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2474 >                   Objects.equals(v2, rs[5].value));
2475 >
2476 >        checkCompletedNormally(f, v1);
2477 >        checkCompletedNormally(g, v2);
2478 >        checkCompletedNormally(h0, null);
2479 >        checkCompletedNormally(h1, null);
2480 >        checkCompletedNormally(h2, null);
2481 >        checkCompletedNormally(h3, null);
2482 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2483 >    }}
2484  
2485      /**
2486 <     * thenCombineAsync result completes exceptionally after exceptional
2486 >     * acceptEither result completes exceptionally after exceptional
2487       * completion of either source
2488       */
2489 <    public void testThenCombineAsync2E() {
2490 <        CompletableFuture<Integer> f, g, h;
2491 <        ThreadExecutor e = new ThreadExecutor();
2492 <        int count = 0;
2493 <
2494 <        f = new CompletableFuture<>();
2495 <        g = new CompletableFuture<>();
2496 <        h = f.thenCombineAsync(g, subtract, e);
2497 <        f.completeExceptionally(new CFException());
2498 <        checkIncomplete(h);
2499 <        g.complete(1);
2500 <        checkCompletedWithWrappedCFException(h);
2501 <
2502 <        f = new CompletableFuture<>();
2503 <        g = new CompletableFuture<>();
2504 <        h = f.thenCombineAsync(g, subtract, e);
2505 <        g.completeExceptionally(new CFException());
2506 <        checkIncomplete(h);
2507 <        f.complete(3);
2508 <        checkCompletedWithWrappedCFException(h);
2509 <
2510 <        f = new CompletableFuture<>();
2511 <        g = new CompletableFuture<>();
2512 <        g.completeExceptionally(new CFException());
2513 <        h = f.thenCombineAsync(g, subtract, e);
2514 <        checkIncomplete(h);
2515 <        f.complete(3);
2516 <        checkCompletedWithWrappedCFException(h);
2517 <
2518 <        assertEquals(0, e.count.get());
2519 <    }
2520 <
2521 <    /**
2522 <     * thenCombineAsync result completes exceptionally if action does
2523 <     */
2524 <    public void testThenCombineAsync3E() {
2525 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2526 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2527 <        FailingBiFunction r = new FailingBiFunction();
2528 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
2529 <        f.complete(one);
2530 <        checkIncomplete(g);
2531 <        assertFalse(r.ran);
2315 <        f2.complete(two);
2316 <        checkCompletedWithWrappedCFException(g);
2317 <        assertTrue(r.ran);
2318 <    }
2319 <
2320 <    /**
2321 <     * thenCombineAsync result completes exceptionally if either source cancelled
2322 <     */
2323 <    public void testThenCombineAsync4E() {
2324 <        CompletableFuture<Integer> f, g, h;
2325 <        ThreadExecutor e = new ThreadExecutor();
2326 <
2327 <        f = new CompletableFuture<>();
2328 <        g = new CompletableFuture<>();
2329 <        h = f.thenCombineAsync(g, subtract, e);
2330 <        assertTrue(f.cancel(true));
2331 <        checkIncomplete(h);
2332 <        g.complete(1);
2333 <        checkCompletedWithWrappedCancellationException(h);
2334 <
2335 <        f = new CompletableFuture<>();
2336 <        g = new CompletableFuture<>();
2337 <        h = f.thenCombineAsync(g, subtract, e);
2338 <        assertTrue(g.cancel(true));
2339 <        checkIncomplete(h);
2340 <        f.complete(3);
2341 <        checkCompletedWithWrappedCancellationException(h);
2342 <
2343 <        f = new CompletableFuture<>();
2344 <        g = new CompletableFuture<>();
2345 <        assertTrue(g.cancel(true));
2346 <        h = f.thenCombineAsync(g, subtract, e);
2347 <        checkIncomplete(h);
2348 <        f.complete(3);
2349 <        checkCompletedWithWrappedCancellationException(h);
2350 <
2351 <        f = new CompletableFuture<>();
2352 <        g = new CompletableFuture<>();
2353 <        assertTrue(f.cancel(true));
2354 <        assertTrue(g.cancel(true));
2355 <        h = f.thenCombineAsync(g, subtract, e);
2356 <        checkCompletedWithWrappedCancellationException(h);
2357 <
2358 <        assertEquals(0, e.count.get());
2359 <    }
2360 <
2361 <    /**
2362 <     * thenAcceptBothAsync result completes normally after normal
2363 <     * completion of sources
2364 <     */
2365 <    public void testThenAcceptBothAsyncE() {
2366 <        CompletableFuture<Integer> f, g;
2367 <        CompletableFuture<Void> h;
2368 <        SubtractAction r;
2369 <        ThreadExecutor e = new ThreadExecutor();
2370 <
2371 <        f = new CompletableFuture<>();
2372 <        g = new CompletableFuture<>();
2373 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2374 <        f.complete(3);
2375 <        checkIncomplete(h);
2376 <        g.complete(1);
2377 <        checkCompletedNormally(h, null);
2378 <        assertEquals(r.value, 2);
2379 <
2380 <        f = new CompletableFuture<>();
2381 <        g = new CompletableFuture<>();
2382 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2383 <        g.complete(1);
2384 <        checkIncomplete(h);
2385 <        f.complete(3);
2386 <        checkCompletedNormally(h, null);
2387 <        assertEquals(r.value, 2);
2388 <
2389 <        f = new CompletableFuture<>();
2390 <        g = new CompletableFuture<>();
2391 <        g.complete(1);
2392 <        f.complete(3);
2393 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2394 <        checkCompletedNormally(h, null);
2395 <        assertEquals(r.value, 2);
2396 <
2397 <        assertEquals(3, e.count.get());
2398 <    }
2399 <
2400 <    /**
2401 <     * thenAcceptBothAsync result completes exceptionally after exceptional
2402 <     * completion of source
2403 <     */
2404 <    public void testThenAcceptBothAsync2E() {
2405 <        CompletableFuture<Integer> f, g;
2406 <        CompletableFuture<Void> h;
2407 <        SubtractAction r;
2408 <        ThreadExecutor e = new ThreadExecutor();
2409 <
2410 <        f = new CompletableFuture<>();
2411 <        g = new CompletableFuture<>();
2412 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2413 <        f.completeExceptionally(new CFException());
2414 <        checkIncomplete(h);
2415 <        g.complete(1);
2416 <        checkCompletedWithWrappedCFException(h);
2417 <
2418 <        f = new CompletableFuture<>();
2419 <        g = new CompletableFuture<>();
2420 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2421 <        g.completeExceptionally(new CFException());
2422 <        checkIncomplete(h);
2423 <        f.complete(3);
2424 <        checkCompletedWithWrappedCFException(h);
2425 <
2426 <        f = new CompletableFuture<>();
2427 <        g = new CompletableFuture<>();
2428 <        f.complete(3);
2429 <        g.completeExceptionally(new CFException());
2430 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2431 <        checkCompletedWithWrappedCFException(h);
2432 <
2433 <        f = new CompletableFuture<>();
2434 <        g = new CompletableFuture<>();
2435 <        f.completeExceptionally(new CFException());
2436 <        g.complete(3);
2437 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2438 <        checkCompletedWithWrappedCFException(h);
2439 <
2440 <        assertEquals(0, e.count.get());
2441 <    }
2442 <
2443 <    /**
2444 <     * thenAcceptBothAsync result completes exceptionally if action does
2445 <     */
2446 <    public void testThenAcceptBothAsync3E() {
2447 <        CompletableFuture<Integer> f, g;
2448 <        CompletableFuture<Void> h;
2449 <        FailingBiConsumer r;
2450 <        ThreadExecutor e = new ThreadExecutor();
2451 <
2452 <        f = new CompletableFuture<>();
2453 <        g = new CompletableFuture<>();
2454 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2455 <        f.complete(3);
2456 <        checkIncomplete(h);
2457 <        g.complete(1);
2458 <        checkCompletedWithWrappedCFException(h);
2459 <
2460 <        f = new CompletableFuture<>();
2461 <        g = new CompletableFuture<>();
2462 <        f.complete(3);
2463 <        g.complete(1);
2464 <        h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2465 <        checkCompletedWithWrappedCFException(h);
2466 <
2467 <        assertEquals(2, e.count.get());
2468 <    }
2469 <
2470 <    /**
2471 <     * thenAcceptBothAsync result completes exceptionally if either source cancelled
2472 <     */
2473 <    public void testThenAcceptBothAsync4E() {
2474 <        CompletableFuture<Integer> f, g;
2475 <        CompletableFuture<Void> h;
2476 <        SubtractAction r;
2477 <        ThreadExecutor e = new ThreadExecutor();
2478 <
2479 <        f = new CompletableFuture<>();
2480 <        g = new CompletableFuture<>();
2481 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2482 <        assertTrue(f.cancel(true));
2483 <        checkIncomplete(h);
2484 <        g.complete(1);
2485 <        checkCompletedWithWrappedCancellationException(h);
2486 <
2487 <        f = new CompletableFuture<>();
2488 <        g = new CompletableFuture<>();
2489 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2490 <        assertTrue(g.cancel(true));
2491 <        checkIncomplete(h);
2492 <        f.complete(3);
2493 <        checkCompletedWithWrappedCancellationException(h);
2494 <
2495 <        f = new CompletableFuture<>();
2496 <        g = new CompletableFuture<>();
2497 <        f.complete(3);
2498 <        assertTrue(g.cancel(true));
2499 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2500 <        checkCompletedWithWrappedCancellationException(h);
2501 <
2502 <        f = new CompletableFuture<>();
2503 <        g = new CompletableFuture<>();
2504 <        assertTrue(f.cancel(true));
2505 <        g.complete(3);
2506 <        h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2507 <        checkCompletedWithWrappedCancellationException(h);
2508 <
2509 <        assertEquals(0, e.count.get());
2510 <    }
2511 <
2512 <    /**
2513 <     * runAfterBothAsync result completes normally after normal
2514 <     * completion of sources
2515 <     */
2516 <    public void testRunAfterBothAsyncE() {
2517 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2518 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2519 <        Noop r = new Noop();
2520 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2521 <        f.complete(one);
2522 <        checkIncomplete(g);
2523 <        f2.complete(two);
2524 <        checkCompletedNormally(g, null);
2525 <        assertTrue(r.ran);
2526 <    }
2527 <
2528 <    /**
2529 <     * runAfterBothAsync result completes exceptionally after exceptional
2530 <     * completion of source
2531 <     */
2532 <    public void testRunAfterBothAsync2E() {
2533 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2534 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2535 <        Noop r = new Noop();
2536 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2537 <        f.completeExceptionally(new CFException());
2538 <        f2.complete(two);
2539 <        checkCompletedWithWrappedCFException(g);
2489 >    public void testAcceptEither_exceptionalCompletion() {
2490 >        for (ExecutionMode m : ExecutionMode.values())
2491 >        for (Integer v1 : new Integer[] { 1, null })
2492 >    {
2493 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2494 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2495 >        final CFException ex = new CFException();
2496 >        final NoopConsumer[] rs = new NoopConsumer[6];
2497 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(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 >        checkIncomplete(h0);
2502 >        checkIncomplete(h1);
2503 >        rs[0].assertNotInvoked();
2504 >        rs[1].assertNotInvoked();
2505 >        f.completeExceptionally(ex);
2506 >        checkCompletedWithWrappedException(h0, ex);
2507 >        checkCompletedWithWrappedException(h1, ex);
2508 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2509 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2510 >        checkCompletedWithWrappedException(h2, ex);
2511 >        checkCompletedWithWrappedException(h3, ex);
2512 >
2513 >        g.complete(v1);
2514 >
2515 >        // unspecified behavior - both source completions available
2516 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2517 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2518 >        try {
2519 >            assertNull(h4.join());
2520 >            rs[4].assertValue(v1);
2521 >        } catch (CompletionException ok) {
2522 >            checkCompletedWithWrappedException(h4, ex);
2523 >            rs[4].assertNotInvoked();
2524 >        }
2525 >        try {
2526 >            assertNull(h5.join());
2527 >            rs[5].assertValue(v1);
2528 >        } catch (CompletionException ok) {
2529 >            checkCompletedWithWrappedException(h5, ex);
2530 >            rs[5].assertNotInvoked();
2531 >        }
2532  
2533 <        r = new Noop();
2534 <        f = new CompletableFuture<>();
2535 <        f2 = new CompletableFuture<>();
2536 <        g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2537 <        f.complete(one);
2538 <        f2.completeExceptionally(new CFException());
2539 <        checkCompletedWithWrappedCFException(g);
2540 <    }
2533 >        checkCompletedExceptionally(f, ex);
2534 >        checkCompletedNormally(g, v1);
2535 >        checkCompletedWithWrappedException(h0, ex);
2536 >        checkCompletedWithWrappedException(h1, ex);
2537 >        checkCompletedWithWrappedException(h2, ex);
2538 >        checkCompletedWithWrappedException(h3, ex);
2539 >        checkCompletedWithWrappedException(h4, ex);
2540 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2541 >    }}
2542 >
2543 >    public void testAcceptEither_exceptionalCompletion2() {
2544 >        for (ExecutionMode m : ExecutionMode.values())
2545 >        for (boolean fFirst : new boolean[] { true, false })
2546 >        for (Integer v1 : new Integer[] { 1, null })
2547 >    {
2548 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2549 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2550 >        final CFException ex = new CFException();
2551 >        final NoopConsumer[] rs = new NoopConsumer[6];
2552 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2553 >
2554 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2555 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2556 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2557 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2558 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2559 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2560  
2561 <    /**
2562 <     * runAfterBothAsync result completes exceptionally if action does
2563 <     */
2564 <    public void testRunAfterBothAsync3E() {
2565 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2566 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2567 <        FailingNoop r = new FailingNoop();
2568 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2569 <        f.complete(one);
2570 <        checkIncomplete(g);
2571 <        f2.complete(two);
2572 <        checkCompletedWithWrappedCFException(g);
2573 <    }
2574 <
2575 <    /**
2576 <     * runAfterBothAsync result completes exceptionally if either source cancelled
2577 <     */
2578 <    public void testRunAfterBothAsync4E() {
2579 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2580 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2581 <        Noop r = new Noop();
2582 <        CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2583 <        assertTrue(f.cancel(true));
2584 <        f2.complete(two);
2585 <        checkCompletedWithWrappedCancellationException(g);
2561 >        // unspecified behavior - both source completions available
2562 >        try {
2563 >            assertNull(h0.join());
2564 >            rs[0].assertValue(v1);
2565 >        } catch (CompletionException ok) {
2566 >            checkCompletedWithWrappedException(h0, ex);
2567 >            rs[0].assertNotInvoked();
2568 >        }
2569 >        try {
2570 >            assertNull(h1.join());
2571 >            rs[1].assertValue(v1);
2572 >        } catch (CompletionException ok) {
2573 >            checkCompletedWithWrappedException(h1, ex);
2574 >            rs[1].assertNotInvoked();
2575 >        }
2576 >        try {
2577 >            assertNull(h2.join());
2578 >            rs[2].assertValue(v1);
2579 >        } catch (CompletionException ok) {
2580 >            checkCompletedWithWrappedException(h2, ex);
2581 >            rs[2].assertNotInvoked();
2582 >        }
2583 >        try {
2584 >            assertNull(h3.join());
2585 >            rs[3].assertValue(v1);
2586 >        } catch (CompletionException ok) {
2587 >            checkCompletedWithWrappedException(h3, ex);
2588 >            rs[3].assertNotInvoked();
2589 >        }
2590  
2591 <        r = new Noop();
2592 <        f = new CompletableFuture<>();
2593 <        f2 = new CompletableFuture<>();
2579 <        g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2580 <        f.complete(one);
2581 <        assertTrue(f2.cancel(true));
2582 <        checkCompletedWithWrappedCancellationException(g);
2583 <    }
2591 >        checkCompletedNormally(f, v1);
2592 >        checkCompletedExceptionally(g, ex);
2593 >    }}
2594  
2595      /**
2596 <     * applyToEitherAsync result completes normally after normal
2587 <     * completion of sources
2596 >     * acceptEither result completes exceptionally if either source cancelled
2597       */
2598 <    public void testApplyToEitherAsyncE() {
2599 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2600 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2601 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2602 <        f.complete(one);
2603 <        checkCompletedNormally(g, two);
2598 >    public void testAcceptEither_sourceCancelled() {
2599 >        for (ExecutionMode m : ExecutionMode.values())
2600 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2601 >        for (Integer v1 : new Integer[] { 1, null })
2602 >    {
2603 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2604 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2605 >        final NoopConsumer[] rs = new NoopConsumer[6];
2606 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2607 >
2608 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2609 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2610 >        checkIncomplete(h0);
2611 >        checkIncomplete(h1);
2612 >        rs[0].assertNotInvoked();
2613 >        rs[1].assertNotInvoked();
2614 >        f.cancel(mayInterruptIfRunning);
2615 >        checkCompletedWithWrappedCancellationException(h0);
2616 >        checkCompletedWithWrappedCancellationException(h1);
2617 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2618 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2619 >        checkCompletedWithWrappedCancellationException(h2);
2620 >        checkCompletedWithWrappedCancellationException(h3);
2621 >
2622 >        g.complete(v1);
2623 >
2624 >        // unspecified behavior - both source completions available
2625 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2626 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2627 >        try {
2628 >            assertNull(h4.join());
2629 >            rs[4].assertValue(v1);
2630 >        } catch (CompletionException ok) {
2631 >            checkCompletedWithWrappedCancellationException(h4);
2632 >            rs[4].assertNotInvoked();
2633 >        }
2634 >        try {
2635 >            assertNull(h5.join());
2636 >            rs[5].assertValue(v1);
2637 >        } catch (CompletionException ok) {
2638 >            checkCompletedWithWrappedCancellationException(h5);
2639 >            rs[5].assertNotInvoked();
2640 >        }
2641  
2642 <        f = new CompletableFuture<>();
2643 <        f.complete(one);
2644 <        f2 = new CompletableFuture<>();
2645 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2646 <        checkCompletedNormally(g, two);
2647 <    }
2642 >        checkCancelled(f);
2643 >        checkCompletedNormally(g, v1);
2644 >        checkCompletedWithWrappedCancellationException(h0);
2645 >        checkCompletedWithWrappedCancellationException(h1);
2646 >        checkCompletedWithWrappedCancellationException(h2);
2647 >        checkCompletedWithWrappedCancellationException(h3);
2648 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2649 >    }}
2650  
2651      /**
2652 <     * applyToEitherAsync result completes exceptionally after exceptional
2605 <     * completion of source
2652 >     * acceptEither result completes exceptionally if action does
2653       */
2654 <    public void testApplyToEitherAsync2E() {
2655 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2656 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2657 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2658 <        f.completeExceptionally(new CFException());
2659 <        checkCompletedWithWrappedCFException(g);
2660 <
2661 <        f = new CompletableFuture<>();
2662 <        f2 = new CompletableFuture<>();
2663 <        f2.completeExceptionally(new CFException());
2664 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2665 <        f.complete(one);
2666 <        checkCompletedWithWrappedCFException(g);
2667 <    }
2654 >    public void testAcceptEither_actionFailed() {
2655 >        for (ExecutionMode m : ExecutionMode.values())
2656 >        for (Integer v1 : new Integer[] { 1, null })
2657 >        for (Integer v2 : new Integer[] { 2, null })
2658 >    {
2659 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2660 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2661 >        final FailingConsumer[] rs = new FailingConsumer[6];
2662 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2663 >
2664 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2665 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2666 >        f.complete(v1);
2667 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2668 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2669 >        checkCompletedWithWrappedException(h0, rs[0].ex);
2670 >        checkCompletedWithWrappedException(h1, rs[1].ex);
2671 >        checkCompletedWithWrappedException(h2, rs[2].ex);
2672 >        checkCompletedWithWrappedException(h3, rs[3].ex);
2673 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2674 >
2675 >        g.complete(v2);
2676 >
2677 >        // unspecified behavior - both source completions available
2678 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2679 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2680 >
2681 >        checkCompletedWithWrappedException(h4, rs[4].ex);
2682 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2683 >                   Objects.equals(v2, rs[4].value));
2684 >        checkCompletedWithWrappedException(h5, rs[5].ex);
2685 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2686 >                   Objects.equals(v2, rs[5].value));
2687 >
2688 >        checkCompletedNormally(f, v1);
2689 >        checkCompletedNormally(g, v2);
2690 >    }}
2691  
2692      /**
2693 <     * applyToEitherAsync result completes exceptionally if action does
2693 >     * runAfterEither result completes normally after normal completion
2694 >     * of either source
2695       */
2696 <    public void testApplyToEitherAsync3E() {
2697 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2698 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2699 <        FailingFunction r = new FailingFunction();
2700 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
2701 <        f.complete(one);
2702 <        checkCompletedWithWrappedCFException(g);
2703 <    }
2696 >    public void testRunAfterEither_normalCompletion() {
2697 >        for (ExecutionMode m : ExecutionMode.values())
2698 >        for (Integer v1 : new Integer[] { 1, null })
2699 >        for (Integer v2 : new Integer[] { 2, null })
2700 >        for (boolean pushNop : new boolean[] { true, false })
2701 >    {
2702 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2703 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2704 >        final Noop[] rs = new Noop[6];
2705 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2706 >
2707 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2708 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2709 >        checkIncomplete(h0);
2710 >        checkIncomplete(h1);
2711 >        rs[0].assertNotInvoked();
2712 >        rs[1].assertNotInvoked();
2713 >        if (pushNop) {          // ad hoc test of intra-completion interference
2714 >            m.thenRun(f, () -> {});
2715 >            m.thenRun(g, () -> {});
2716 >        }
2717 >        f.complete(v1);
2718 >        checkCompletedNormally(h0, null);
2719 >        checkCompletedNormally(h1, null);
2720 >        rs[0].assertInvoked();
2721 >        rs[1].assertInvoked();
2722 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2723 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2724 >        checkCompletedNormally(h2, null);
2725 >        checkCompletedNormally(h3, null);
2726 >        rs[2].assertInvoked();
2727 >        rs[3].assertInvoked();
2728 >
2729 >        g.complete(v2);
2730 >
2731 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2732 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2733 >
2734 >        checkCompletedNormally(f, v1);
2735 >        checkCompletedNormally(g, v2);
2736 >        checkCompletedNormally(h0, null);
2737 >        checkCompletedNormally(h1, null);
2738 >        checkCompletedNormally(h2, null);
2739 >        checkCompletedNormally(h3, null);
2740 >        checkCompletedNormally(h4, null);
2741 >        checkCompletedNormally(h5, null);
2742 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2743 >    }}
2744  
2745      /**
2746 <     * applyToEitherAsync result completes exceptionally if either source cancelled
2746 >     * runAfterEither result completes exceptionally after exceptional
2747 >     * completion of either source
2748       */
2749 <    public void testApplyToEitherAsync4E() {
2750 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2751 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2752 <        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2753 <        assertTrue(f.cancel(true));
2754 <        checkCompletedWithWrappedCancellationException(g);
2749 >    public void testRunAfterEither_exceptionalCompletion() {
2750 >        for (ExecutionMode m : ExecutionMode.values())
2751 >        for (Integer v1 : new Integer[] { 1, null })
2752 >    {
2753 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2754 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2755 >        final CFException ex = new CFException();
2756 >        final Noop[] rs = new Noop[6];
2757 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2758 >
2759 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2760 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2761 >        checkIncomplete(h0);
2762 >        checkIncomplete(h1);
2763 >        rs[0].assertNotInvoked();
2764 >        rs[1].assertNotInvoked();
2765 >        assertTrue(f.completeExceptionally(ex));
2766 >        checkCompletedWithWrappedException(h0, ex);
2767 >        checkCompletedWithWrappedException(h1, ex);
2768 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2769 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2770 >        checkCompletedWithWrappedException(h2, ex);
2771 >        checkCompletedWithWrappedException(h3, ex);
2772 >
2773 >        assertTrue(g.complete(v1));
2774 >
2775 >        // unspecified behavior - both source completions available
2776 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2777 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2778 >        try {
2779 >            assertNull(h4.join());
2780 >            rs[4].assertInvoked();
2781 >        } catch (CompletionException ok) {
2782 >            checkCompletedWithWrappedException(h4, ex);
2783 >            rs[4].assertNotInvoked();
2784 >        }
2785 >        try {
2786 >            assertNull(h5.join());
2787 >            rs[5].assertInvoked();
2788 >        } catch (CompletionException ok) {
2789 >            checkCompletedWithWrappedException(h5, ex);
2790 >            rs[5].assertNotInvoked();
2791 >        }
2792  
2793 <        f = new CompletableFuture<>();
2794 <        f2 = new CompletableFuture<>();
2795 <        assertTrue(f2.cancel(true));
2796 <        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2797 <        checkCompletedWithWrappedCancellationException(g);
2798 <    }
2793 >        checkCompletedExceptionally(f, ex);
2794 >        checkCompletedNormally(g, v1);
2795 >        checkCompletedWithWrappedException(h0, ex);
2796 >        checkCompletedWithWrappedException(h1, ex);
2797 >        checkCompletedWithWrappedException(h2, ex);
2798 >        checkCompletedWithWrappedException(h3, ex);
2799 >        checkCompletedWithWrappedException(h4, ex);
2800 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2801 >    }}
2802 >
2803 >    public void testRunAfterEither_exceptionalCompletion2() {
2804 >        for (ExecutionMode m : ExecutionMode.values())
2805 >        for (boolean fFirst : new boolean[] { true, false })
2806 >        for (Integer v1 : new Integer[] { 1, null })
2807 >    {
2808 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2809 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2810 >        final CFException ex = new CFException();
2811 >        final Noop[] rs = new Noop[6];
2812 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2813 >
2814 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2815 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2816 >        assertTrue( fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2817 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2818 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2819 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2820  
2821 <    /**
2822 <     * acceptEitherAsync result completes normally after normal
2823 <     * completion of sources
2824 <     */
2825 <    public void testAcceptEitherAsyncE() {
2826 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2827 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2828 <        IncAction r = new IncAction();
2829 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2830 <        f.complete(one);
2831 <        checkCompletedNormally(g, null);
2832 <        assertEquals(r.value, 2);
2821 >        // unspecified behavior - both source completions available
2822 >        try {
2823 >            assertNull(h0.join());
2824 >            rs[0].assertInvoked();
2825 >        } catch (CompletionException ok) {
2826 >            checkCompletedWithWrappedException(h0, ex);
2827 >            rs[0].assertNotInvoked();
2828 >        }
2829 >        try {
2830 >            assertNull(h1.join());
2831 >            rs[1].assertInvoked();
2832 >        } catch (CompletionException ok) {
2833 >            checkCompletedWithWrappedException(h1, ex);
2834 >            rs[1].assertNotInvoked();
2835 >        }
2836 >        try {
2837 >            assertNull(h2.join());
2838 >            rs[2].assertInvoked();
2839 >        } catch (CompletionException ok) {
2840 >            checkCompletedWithWrappedException(h2, ex);
2841 >            rs[2].assertNotInvoked();
2842 >        }
2843 >        try {
2844 >            assertNull(h3.join());
2845 >            rs[3].assertInvoked();
2846 >        } catch (CompletionException ok) {
2847 >            checkCompletedWithWrappedException(h3, ex);
2848 >            rs[3].assertNotInvoked();
2849 >        }
2850  
2851 <        r = new IncAction();
2852 <        f = new CompletableFuture<>();
2853 <        f.complete(one);
2667 <        f2 = new CompletableFuture<>();
2668 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2669 <        checkCompletedNormally(g, null);
2670 <        assertEquals(r.value, 2);
2671 <    }
2851 >        checkCompletedNormally(f, v1);
2852 >        checkCompletedExceptionally(g, ex);
2853 >    }}
2854  
2855      /**
2856 <     * acceptEitherAsync result completes exceptionally after exceptional
2675 <     * completion of source
2856 >     * runAfterEither result completes exceptionally if either source cancelled
2857       */
2858 <    public void testAcceptEitherAsync2E() {
2859 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2860 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2861 <        IncAction r = new IncAction();
2862 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2863 <        f.completeExceptionally(new CFException());
2864 <        checkCompletedWithWrappedCFException(g);
2865 <
2866 <        r = new IncAction();
2867 <        f = new CompletableFuture<>();
2868 <        f2 = new CompletableFuture<>();
2869 <        f2.completeExceptionally(new CFException());
2870 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2871 <        f.complete(one);
2872 <        checkCompletedWithWrappedCFException(g);
2873 <    }
2858 >    public void testRunAfterEither_sourceCancelled() {
2859 >        for (ExecutionMode m : ExecutionMode.values())
2860 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2861 >        for (Integer v1 : new Integer[] { 1, null })
2862 >    {
2863 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2864 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2865 >        final Noop[] rs = new Noop[6];
2866 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2867 >
2868 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2869 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2870 >        checkIncomplete(h0);
2871 >        checkIncomplete(h1);
2872 >        rs[0].assertNotInvoked();
2873 >        rs[1].assertNotInvoked();
2874 >        f.cancel(mayInterruptIfRunning);
2875 >        checkCompletedWithWrappedCancellationException(h0);
2876 >        checkCompletedWithWrappedCancellationException(h1);
2877 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2878 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2879 >        checkCompletedWithWrappedCancellationException(h2);
2880 >        checkCompletedWithWrappedCancellationException(h3);
2881 >
2882 >        assertTrue(g.complete(v1));
2883 >
2884 >        // unspecified behavior - both source completions available
2885 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2886 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2887 >        try {
2888 >            assertNull(h4.join());
2889 >            rs[4].assertInvoked();
2890 >        } catch (CompletionException ok) {
2891 >            checkCompletedWithWrappedCancellationException(h4);
2892 >            rs[4].assertNotInvoked();
2893 >        }
2894 >        try {
2895 >            assertNull(h5.join());
2896 >            rs[5].assertInvoked();
2897 >        } catch (CompletionException ok) {
2898 >            checkCompletedWithWrappedCancellationException(h5);
2899 >            rs[5].assertNotInvoked();
2900 >        }
2901  
2902 <    /**
2903 <     * acceptEitherAsync result completes exceptionally if action does
2904 <     */
2905 <    public void testAcceptEitherAsync3E() {
2906 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2907 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2908 <        FailingConsumer r = new FailingConsumer();
2909 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2702 <        f.complete(one);
2703 <        checkCompletedWithWrappedCFException(g);
2704 <    }
2902 >        checkCancelled(f);
2903 >        checkCompletedNormally(g, v1);
2904 >        checkCompletedWithWrappedCancellationException(h0);
2905 >        checkCompletedWithWrappedCancellationException(h1);
2906 >        checkCompletedWithWrappedCancellationException(h2);
2907 >        checkCompletedWithWrappedCancellationException(h3);
2908 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2909 >    }}
2910  
2911      /**
2912 <     * acceptEitherAsync result completes exceptionally if either
2708 <     * source cancelled
2912 >     * runAfterEither result completes exceptionally if action does
2913       */
2914 <    public void testAcceptEitherAsync4E() {
2915 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2916 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2917 <        IncAction r = new IncAction();
2918 <        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2919 <        assertTrue(f.cancel(true));
2920 <        checkCompletedWithWrappedCancellationException(g);
2921 <
2922 <        r = new IncAction();
2923 <        f = new CompletableFuture<>();
2924 <        f2 = new CompletableFuture<>();
2925 <        assertTrue(f2.cancel(true));
2926 <        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2927 <        checkCompletedWithWrappedCancellationException(g);
2928 <    }
2914 >    public void testRunAfterEither_actionFailed() {
2915 >        for (ExecutionMode m : ExecutionMode.values())
2916 >        for (Integer v1 : new Integer[] { 1, null })
2917 >        for (Integer v2 : new Integer[] { 2, null })
2918 >    {
2919 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2920 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
2921 >        final FailingRunnable[] rs = new FailingRunnable[6];
2922 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2923 >
2924 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2925 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2926 >        assertTrue(f.complete(v1));
2927 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2928 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2929 >        checkCompletedWithWrappedException(h0, rs[0].ex);
2930 >        checkCompletedWithWrappedException(h1, rs[1].ex);
2931 >        checkCompletedWithWrappedException(h2, rs[2].ex);
2932 >        checkCompletedWithWrappedException(h3, rs[3].ex);
2933 >        for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2934 >        assertTrue(g.complete(v2));
2935 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2936 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2937 >        checkCompletedWithWrappedException(h4, rs[4].ex);
2938 >        checkCompletedWithWrappedException(h5, rs[5].ex);
2939 >
2940 >        checkCompletedNormally(f, v1);
2941 >        checkCompletedNormally(g, v2);
2942 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2943 >    }}
2944  
2945      /**
2946 <     * runAfterEitherAsync result completes normally after normal
2728 <     * completion of sources
2946 >     * thenCompose result completes normally after normal completion of source
2947       */
2948 <    public void testRunAfterEitherAsyncE() {
2949 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2950 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2951 <        Noop r = new Noop();
2952 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2953 <        f.complete(one);
2954 <        checkCompletedNormally(g, null);
2955 <        assertTrue(r.ran);
2956 <
2957 <        r = new Noop();
2958 <        f = new CompletableFuture<>();
2959 <        f.complete(one);
2960 <        f2 = new CompletableFuture<>();
2961 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2962 <        checkCompletedNormally(g, null);
2745 <        assertTrue(r.ran);
2746 <    }
2948 >    public void testThenCompose_normalCompletion() {
2949 >        for (ExecutionMode m : ExecutionMode.values())
2950 >        for (boolean createIncomplete : new boolean[] { true, false })
2951 >        for (Integer v1 : new Integer[] { 1, null })
2952 >    {
2953 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2954 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2955 >        if (!createIncomplete) assertTrue(f.complete(v1));
2956 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2957 >        if (createIncomplete) assertTrue(f.complete(v1));
2958 >
2959 >        checkCompletedNormally(g, inc(v1));
2960 >        checkCompletedNormally(f, v1);
2961 >        r.assertValue(v1);
2962 >    }}
2963  
2964      /**
2965 <     * runAfterEitherAsync result completes exceptionally after exceptional
2965 >     * thenCompose result completes exceptionally after exceptional
2966       * completion of source
2967       */
2968 <    public void testRunAfterEitherAsync2E() {
2969 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2970 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2971 <        Noop r = new Noop();
2972 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2973 <        f.completeExceptionally(new CFException());
2974 <        checkCompletedWithWrappedCFException(g);
2975 <
2976 <        r = new Noop();
2977 <        f = new CompletableFuture<>();
2978 <        f2 = new CompletableFuture<>();
2979 <        f2.completeExceptionally(new CFException());
2980 <        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2981 <        f.complete(one);
2982 <        checkCompletedWithWrappedCFException(g);
2767 <    }
2968 >    public void testThenCompose_exceptionalCompletion() {
2969 >        for (ExecutionMode m : ExecutionMode.values())
2970 >        for (boolean createIncomplete : new boolean[] { true, false })
2971 >    {
2972 >        final CFException ex = new CFException();
2973 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2974 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2975 >        if (!createIncomplete) f.completeExceptionally(ex);
2976 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2977 >        if (createIncomplete) f.completeExceptionally(ex);
2978 >
2979 >        checkCompletedWithWrappedException(g, ex);
2980 >        checkCompletedExceptionally(f, ex);
2981 >        r.assertNotInvoked();
2982 >    }}
2983  
2984      /**
2985 <     * runAfterEitherAsync result completes exceptionally if action does
2985 >     * thenCompose result completes exceptionally if action does
2986       */
2987 <    public void testRunAfterEitherAsync3E() {
2988 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2989 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
2990 <        FailingNoop r = new FailingNoop();
2991 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2992 <        f.complete(one);
2993 <        checkCompletedWithWrappedCFException(g);
2994 <    }
2987 >    public void testThenCompose_actionFailed() {
2988 >        for (ExecutionMode m : ExecutionMode.values())
2989 >        for (boolean createIncomplete : new boolean[] { true, false })
2990 >        for (Integer v1 : new Integer[] { 1, null })
2991 >    {
2992 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
2993 >        final FailingCompletableFutureFunction r
2994 >            = new FailingCompletableFutureFunction(m);
2995 >        if (!createIncomplete) assertTrue(f.complete(v1));
2996 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2997 >        if (createIncomplete) assertTrue(f.complete(v1));
2998 >
2999 >        checkCompletedWithWrappedException(g, r.ex);
3000 >        checkCompletedNormally(f, v1);
3001 >    }}
3002  
3003      /**
3004 <     * runAfterEitherAsync result completes exceptionally if either
2783 <     * source cancelled
3004 >     * thenCompose result completes exceptionally if source cancelled
3005       */
3006 <    public void testRunAfterEitherAsync4E() {
3007 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3008 <        CompletableFuture<Integer> f2 = new CompletableFuture<>();
3009 <        Noop r = new Noop();
3010 <        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3011 <        assertTrue(f.cancel(true));
3012 <        checkCompletedWithWrappedCancellationException(g);
3006 >    public void testThenCompose_sourceCancelled() {
3007 >        for (ExecutionMode m : ExecutionMode.values())
3008 >        for (boolean createIncomplete : new boolean[] { true, false })
3009 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3010 >    {
3011 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3012 >        final CompletableFutureInc r = new CompletableFutureInc(m);
3013 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3014 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
3015 >        if (createIncomplete) {
3016 >            checkIncomplete(g);
3017 >            assertTrue(f.cancel(mayInterruptIfRunning));
3018 >        }
3019  
2793        r = new Noop();
2794        f = new CompletableFuture<>();
2795        f2 = new CompletableFuture<>();
2796        assertTrue(f2.cancel(true));
2797        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3020          checkCompletedWithWrappedCancellationException(g);
3021 <    }
3022 <
2801 <    /**
2802 <     * thenComposeAsync result completes normally after normal
2803 <     * completion of source
2804 <     */
2805 <    public void testThenComposeAsyncE() {
2806 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2807 <        CompletableFutureInc r = new CompletableFutureInc();
2808 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2809 <        f.complete(one);
2810 <        checkCompletedNormally(g, two);
2811 <    }
2812 <
2813 <    /**
2814 <     * thenComposeAsync result completes exceptionally after
2815 <     * exceptional completion of source
2816 <     */
2817 <    public void testThenComposeAsync2E() {
2818 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2819 <        CompletableFutureInc r = new CompletableFutureInc();
2820 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2821 <        f.completeExceptionally(new CFException());
2822 <        checkCompletedWithWrappedCFException(g);
2823 <    }
3021 >        checkCancelled(f);
3022 >    }}
3023  
3024      /**
3025 <     * thenComposeAsync result completes exceptionally if action does
3025 >     * thenCompose result completes exceptionally if the result of the action does
3026       */
3027 <    public void testThenComposeAsync3E() {
3028 <        CompletableFuture<Integer> f = new CompletableFuture<>();
3029 <        FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
3030 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3031 <        f.complete(one);
3032 <        checkCompletedWithWrappedCFException(g);
3033 <    }
3027 >    public void testThenCompose_actionReturnsFailingFuture() {
3028 >        for (ExecutionMode m : ExecutionMode.values())
3029 >        for (int order = 0; order < 6; order++)
3030 >        for (Integer v1 : new Integer[] { 1, null })
3031 >    {
3032 >        final CFException ex = new CFException();
3033 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
3034 >        final CompletableFuture<Integer> g = new CompletableFuture<>();
3035 >        final CompletableFuture<Integer> h;
3036 >        // Test all permutations of orders
3037 >        switch (order) {
3038 >        case 0:
3039 >            assertTrue(f.complete(v1));
3040 >            assertTrue(g.completeExceptionally(ex));
3041 >            h = m.thenCompose(f, (x -> g));
3042 >            break;
3043 >        case 1:
3044 >            assertTrue(f.complete(v1));
3045 >            h = m.thenCompose(f, (x -> g));
3046 >            assertTrue(g.completeExceptionally(ex));
3047 >            break;
3048 >        case 2:
3049 >            assertTrue(g.completeExceptionally(ex));
3050 >            assertTrue(f.complete(v1));
3051 >            h = m.thenCompose(f, (x -> g));
3052 >            break;
3053 >        case 3:
3054 >            assertTrue(g.completeExceptionally(ex));
3055 >            h = m.thenCompose(f, (x -> g));
3056 >            assertTrue(f.complete(v1));
3057 >            break;
3058 >        case 4:
3059 >            h = m.thenCompose(f, (x -> g));
3060 >            assertTrue(f.complete(v1));
3061 >            assertTrue(g.completeExceptionally(ex));
3062 >            break;
3063 >        case 5:
3064 >            h = m.thenCompose(f, (x -> g));
3065 >            assertTrue(f.complete(v1));
3066 >            assertTrue(g.completeExceptionally(ex));
3067 >            break;
3068 >        default: throw new AssertionError();
3069 >        }
3070  
3071 <    /**
3072 <     * thenComposeAsync result completes exceptionally if source cancelled
3073 <     */
3074 <    public void testThenComposeAsync4E() {
2840 <        CompletableFuture<Integer> f = new CompletableFuture<>();
2841 <        CompletableFutureInc r = new CompletableFutureInc();
2842 <        CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2843 <        assertTrue(f.cancel(true));
2844 <        checkCompletedWithWrappedCancellationException(g);
2845 <    }
3071 >        checkCompletedExceptionally(g, ex);
3072 >        checkCompletedWithWrappedException(h, ex);
3073 >        checkCompletedNormally(f, v1);
3074 >    }}
3075  
3076      // other static methods
3077  
# Line 2860 | Line 3089 | public class CompletableFutureTest exten
3089       * when all components complete normally
3090       */
3091      public void testAllOf_normal() throws Exception {
3092 <        for (int k = 1; k < 20; ++k) {
3093 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3094 <            for (int i = 0; i < k; ++i)
3092 >        for (int k = 1; k < 10; k++) {
3093 >            CompletableFuture<Integer>[] fs
3094 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3095 >            for (int i = 0; i < k; i++)
3096 >                fs[i] = new CompletableFuture<>();
3097 >            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3098 >            for (int i = 0; i < k; i++) {
3099 >                checkIncomplete(f);
3100 >                checkIncomplete(CompletableFuture.allOf(fs));
3101 >                fs[i].complete(one);
3102 >            }
3103 >            checkCompletedNormally(f, null);
3104 >            checkCompletedNormally(CompletableFuture.allOf(fs), null);
3105 >        }
3106 >    }
3107 >
3108 >    public void testAllOf_normal_backwards() throws Exception {
3109 >        for (int k = 1; k < 10; k++) {
3110 >            CompletableFuture<Integer>[] fs
3111 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3112 >            for (int i = 0; i < k; i++)
3113                  fs[i] = new CompletableFuture<>();
3114              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3115 <            for (int i = 0; i < k; ++i) {
3115 >            for (int i = k - 1; i >= 0; i--) {
3116                  checkIncomplete(f);
3117                  checkIncomplete(CompletableFuture.allOf(fs));
3118                  fs[i].complete(one);
# Line 2875 | Line 3122 | public class CompletableFutureTest exten
3122          }
3123      }
3124  
3125 +    public void testAllOf_exceptional() throws Exception {
3126 +        for (int k = 1; k < 10; k++) {
3127 +            CompletableFuture<Integer>[] fs
3128 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3129 +            CFException ex = new CFException();
3130 +            for (int i = 0; i < k; i++)
3131 +                fs[i] = new CompletableFuture<>();
3132 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3133 +            for (int i = 0; i < k; i++) {
3134 +                checkIncomplete(f);
3135 +                checkIncomplete(CompletableFuture.allOf(fs));
3136 +                if (i != k / 2) {
3137 +                    fs[i].complete(i);
3138 +                    checkCompletedNormally(fs[i], i);
3139 +                } else {
3140 +                    fs[i].completeExceptionally(ex);
3141 +                    checkCompletedExceptionally(fs[i], ex);
3142 +                }
3143 +            }
3144 +            checkCompletedWithWrappedException(f, ex);
3145 +            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3146 +        }
3147 +    }
3148 +
3149      /**
3150       * anyOf(no component futures) returns an incomplete future
3151       */
3152      public void testAnyOf_empty() throws Exception {
3153 +        for (Integer v1 : new Integer[] { 1, null })
3154 +    {
3155          CompletableFuture<Object> f = CompletableFuture.anyOf();
3156          checkIncomplete(f);
3157 <    }
3157 >
3158 >        f.complete(v1);
3159 >        checkCompletedNormally(f, v1);
3160 >    }}
3161  
3162      /**
3163       * anyOf returns a future completed normally with a value when
3164       * a component future does
3165       */
3166      public void testAnyOf_normal() throws Exception {
3167 <        for (int k = 0; k < 10; ++k) {
3167 >        for (int k = 0; k < 10; k++) {
3168              CompletableFuture[] fs = new CompletableFuture[k];
3169 <            for (int i = 0; i < k; ++i)
3169 >            for (int i = 0; i < k; i++)
3170                  fs[i] = new CompletableFuture<>();
3171              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3172              checkIncomplete(f);
3173 <            for (int i = 0; i < k; ++i) {
3174 <                fs[i].complete(one);
3175 <                checkCompletedNormally(f, one);
3176 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3173 >            for (int i = 0; i < k; i++) {
3174 >                fs[i].complete(i);
3175 >                checkCompletedNormally(f, 0);
3176 >                int x = (int) CompletableFuture.anyOf(fs).join();
3177 >                assertTrue(0 <= x && x <= i);
3178 >            }
3179 >        }
3180 >    }
3181 >    public void testAnyOf_normal_backwards() throws Exception {
3182 >        for (int k = 0; k < 10; k++) {
3183 >            CompletableFuture[] fs = new CompletableFuture[k];
3184 >            for (int i = 0; i < k; i++)
3185 >                fs[i] = new CompletableFuture<>();
3186 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3187 >            checkIncomplete(f);
3188 >            for (int i = k - 1; i >= 0; i--) {
3189 >                fs[i].complete(i);
3190 >                checkCompletedNormally(f, k - 1);
3191 >                int x = (int) CompletableFuture.anyOf(fs).join();
3192 >                assertTrue(i <= x && x <= k - 1);
3193              }
3194          }
3195      }
# Line 2906 | Line 3198 | public class CompletableFutureTest exten
3198       * anyOf result completes exceptionally when any component does.
3199       */
3200      public void testAnyOf_exceptional() throws Exception {
3201 <        for (int k = 0; k < 10; ++k) {
3201 >        for (int k = 0; k < 10; k++) {
3202              CompletableFuture[] fs = new CompletableFuture[k];
3203 <            for (int i = 0; i < k; ++i)
3203 >            CFException[] exs = new CFException[k];
3204 >            for (int i = 0; i < k; i++) {
3205                  fs[i] = new CompletableFuture<>();
3206 +                exs[i] = new CFException();
3207 +            }
3208              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3209              checkIncomplete(f);
3210 <            for (int i = 0; i < k; ++i) {
3211 <                fs[i].completeExceptionally(new CFException());
3212 <                checkCompletedWithWrappedCFException(f);
3210 >            for (int i = 0; i < k; i++) {
3211 >                fs[i].completeExceptionally(exs[i]);
3212 >                checkCompletedWithWrappedException(f, exs[0]);
3213 >                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3214 >            }
3215 >        }
3216 >    }
3217 >
3218 >    public void testAnyOf_exceptional_backwards() throws Exception {
3219 >        for (int k = 0; k < 10; k++) {
3220 >            CompletableFuture[] fs = new CompletableFuture[k];
3221 >            CFException[] exs = new CFException[k];
3222 >            for (int i = 0; i < k; i++) {
3223 >                fs[i] = new CompletableFuture<>();
3224 >                exs[i] = new CFException();
3225 >            }
3226 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3227 >            checkIncomplete(f);
3228 >            for (int i = k - 1; i >= 0; i--) {
3229 >                fs[i].completeExceptionally(exs[i]);
3230 >                checkCompletedWithWrappedException(f, exs[k - 1]);
3231                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3232              }
3233          }
# Line 2923 | Line 3236 | public class CompletableFutureTest exten
3236      /**
3237       * Completion methods throw NullPointerException with null arguments
3238       */
3239 +    @SuppressWarnings("FutureReturnValueIgnored")
3240      public void testNPE() {
3241          CompletableFuture<Integer> f = new CompletableFuture<>();
3242          CompletableFuture<Integer> g = new CompletableFuture<>();
3243          CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
2930        CompletableFuture<?> h;
3244          ThreadExecutor exec = new ThreadExecutor();
3245  
3246          Runnable[] throwingActions = {
3247              () -> CompletableFuture.supplyAsync(null),
3248              () -> CompletableFuture.supplyAsync(null, exec),
3249 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
3249 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.SYNC, 42), null),
3250  
3251              () -> CompletableFuture.runAsync(null),
3252              () -> CompletableFuture.runAsync(null, exec),
# Line 2943 | Line 3256 | public class CompletableFutureTest exten
3256  
3257              () -> f.thenApply(null),
3258              () -> f.thenApplyAsync(null),
3259 <            () -> f.thenApplyAsync((x) -> x, null),
3259 >            () -> f.thenApplyAsync(x -> x, null),
3260              () -> f.thenApplyAsync(null, exec),
3261  
3262              () -> f.thenAccept(null),
3263              () -> f.thenAcceptAsync(null),
3264 <            () -> f.thenAcceptAsync((x) -> {} , null),
3264 >            () -> f.thenAcceptAsync(x -> {} , null),
3265              () -> f.thenAcceptAsync(null, exec),
3266  
3267              () -> f.thenRun(null),
# Line 2983 | Line 3296 | public class CompletableFutureTest exten
3296              () -> f.applyToEither(g, null),
3297              () -> f.applyToEitherAsync(g, null),
3298              () -> f.applyToEitherAsync(g, null, exec),
3299 <            () -> f.applyToEither(nullFuture, (x) -> x),
3300 <            () -> f.applyToEitherAsync(nullFuture, (x) -> x),
3301 <            () -> f.applyToEitherAsync(nullFuture, (x) -> x, exec),
3302 <            () -> f.applyToEitherAsync(g, (x) -> x, null),
3299 >            () -> f.applyToEither(nullFuture, x -> x),
3300 >            () -> f.applyToEitherAsync(nullFuture, x -> x),
3301 >            () -> f.applyToEitherAsync(nullFuture, x -> x, exec),
3302 >            () -> f.applyToEitherAsync(g, x -> x, null),
3303  
3304              () -> f.acceptEither(g, null),
3305              () -> f.acceptEitherAsync(g, null),
3306              () -> f.acceptEitherAsync(g, null, exec),
3307 <            () -> f.acceptEither(nullFuture, (x) -> {}),
3308 <            () -> f.acceptEitherAsync(nullFuture, (x) -> {}),
3309 <            () -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec),
3310 <            () -> f.acceptEitherAsync(g, (x) -> {}, null),
3307 >            () -> f.acceptEither(nullFuture, x -> {}),
3308 >            () -> f.acceptEitherAsync(nullFuture, x -> {}),
3309 >            () -> f.acceptEitherAsync(nullFuture, x -> {}, exec),
3310 >            () -> f.acceptEitherAsync(g, x -> {}, null),
3311  
3312              () -> f.runAfterEither(g, null),
3313              () -> f.runAfterEitherAsync(g, null),
# Line 3006 | Line 3319 | public class CompletableFutureTest exten
3319  
3320              () -> f.thenCompose(null),
3321              () -> f.thenComposeAsync(null),
3322 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
3322 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
3323              () -> f.thenComposeAsync(null, exec),
3324  
3325              () -> f.exceptionally(null),
# Line 3024 | Line 3337 | public class CompletableFutureTest exten
3337              () -> CompletableFuture.anyOf(null, f),
3338  
3339              () -> f.obtrudeException(null),
3340 +
3341 +            () -> CompletableFuture.delayedExecutor(1L, SECONDS, null),
3342 +            () -> CompletableFuture.delayedExecutor(1L, null, exec),
3343 +            () -> CompletableFuture.delayedExecutor(1L, null),
3344 +
3345 +            () -> f.orTimeout(1L, null),
3346 +            () -> f.completeOnTimeout(42, 1L, null),
3347 +
3348 +            () -> CompletableFuture.failedFuture(null),
3349 +            () -> CompletableFuture.failedStage(null),
3350          };
3351  
3352          assertThrows(NullPointerException.class, throwingActions);
# Line 3031 | Line 3354 | public class CompletableFutureTest exten
3354      }
3355  
3356      /**
3357 +     * Test submissions to an executor that rejects all tasks.
3358 +     */
3359 +    public void testRejectingExecutor() {
3360 +        for (Integer v : new Integer[] { 1, null })
3361 +    {
3362 +        final CountingRejectingExecutor e = new CountingRejectingExecutor();
3363 +
3364 +        final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3365 +        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3366 +
3367 +        List<CompletableFuture<?>> futures = new ArrayList<>();
3368 +
3369 +        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3370 +        srcs.add(complete);
3371 +        srcs.add(incomplete);
3372 +
3373 +        for (CompletableFuture<Integer> src : srcs) {
3374 +            List<CompletableFuture<?>> fs = new ArrayList<>();
3375 +            fs.add(src.thenRunAsync(() -> {}, e));
3376 +            fs.add(src.thenAcceptAsync(z -> {}, e));
3377 +            fs.add(src.thenApplyAsync(z -> z, e));
3378 +
3379 +            fs.add(src.thenCombineAsync(src, (x, y) -> x, e));
3380 +            fs.add(src.thenAcceptBothAsync(src, (x, y) -> {}, e));
3381 +            fs.add(src.runAfterBothAsync(src, () -> {}, e));
3382 +
3383 +            fs.add(src.applyToEitherAsync(src, z -> z, e));
3384 +            fs.add(src.acceptEitherAsync(src, z -> {}, e));
3385 +            fs.add(src.runAfterEitherAsync(src, () -> {}, e));
3386 +
3387 +            fs.add(src.thenComposeAsync(z -> null, e));
3388 +            fs.add(src.whenCompleteAsync((z, t) -> {}, e));
3389 +            fs.add(src.handleAsync((z, t) -> null, e));
3390 +
3391 +            for (CompletableFuture<?> future : fs) {
3392 +                if (src.isDone())
3393 +                    checkCompletedWithWrappedException(future, e.ex);
3394 +                else
3395 +                    checkIncomplete(future);
3396 +            }
3397 +            futures.addAll(fs);
3398 +        }
3399 +
3400 +        {
3401 +            List<CompletableFuture<?>> fs = new ArrayList<>();
3402 +
3403 +            fs.add(complete.thenCombineAsync(incomplete, (x, y) -> x, e));
3404 +            fs.add(incomplete.thenCombineAsync(complete, (x, y) -> x, e));
3405 +
3406 +            fs.add(complete.thenAcceptBothAsync(incomplete, (x, y) -> {}, e));
3407 +            fs.add(incomplete.thenAcceptBothAsync(complete, (x, y) -> {}, e));
3408 +
3409 +            fs.add(complete.runAfterBothAsync(incomplete, () -> {}, e));
3410 +            fs.add(incomplete.runAfterBothAsync(complete, () -> {}, e));
3411 +
3412 +            for (CompletableFuture<?> future : fs)
3413 +                checkIncomplete(future);
3414 +            futures.addAll(fs);
3415 +        }
3416 +
3417 +        {
3418 +            List<CompletableFuture<?>> fs = new ArrayList<>();
3419 +
3420 +            fs.add(complete.applyToEitherAsync(incomplete, z -> z, e));
3421 +            fs.add(incomplete.applyToEitherAsync(complete, z -> z, e));
3422 +
3423 +            fs.add(complete.acceptEitherAsync(incomplete, z -> {}, e));
3424 +            fs.add(incomplete.acceptEitherAsync(complete, z -> {}, e));
3425 +
3426 +            fs.add(complete.runAfterEitherAsync(incomplete, () -> {}, e));
3427 +            fs.add(incomplete.runAfterEitherAsync(complete, () -> {}, e));
3428 +
3429 +            for (CompletableFuture<?> future : fs)
3430 +                checkCompletedWithWrappedException(future, e.ex);
3431 +            futures.addAll(fs);
3432 +        }
3433 +
3434 +        incomplete.complete(v);
3435 +
3436 +        for (CompletableFuture<?> future : futures)
3437 +            checkCompletedWithWrappedException(future, e.ex);
3438 +
3439 +        assertEquals(futures.size(), e.count.get());
3440 +    }}
3441 +
3442 +    /**
3443 +     * Test submissions to an executor that rejects all tasks, but
3444 +     * should never be invoked because the dependent future is
3445 +     * explicitly completed.
3446 +     */
3447 +    public void testRejectingExecutorNeverInvoked() {
3448 +        for (Integer v : new Integer[] { 1, null })
3449 +    {
3450 +        final CountingRejectingExecutor e = new CountingRejectingExecutor();
3451 +
3452 +        final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3453 +        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3454 +
3455 +        List<CompletableFuture<?>> futures = new ArrayList<>();
3456 +
3457 +        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3458 +        srcs.add(complete);
3459 +        srcs.add(incomplete);
3460 +
3461 +        List<CompletableFuture<?>> fs = new ArrayList<>();
3462 +        fs.add(incomplete.thenRunAsync(() -> {}, e));
3463 +        fs.add(incomplete.thenAcceptAsync(z -> {}, e));
3464 +        fs.add(incomplete.thenApplyAsync(z -> z, e));
3465 +
3466 +        fs.add(incomplete.thenCombineAsync(incomplete, (x, y) -> x, e));
3467 +        fs.add(incomplete.thenAcceptBothAsync(incomplete, (x, y) -> {}, e));
3468 +        fs.add(incomplete.runAfterBothAsync(incomplete, () -> {}, e));
3469 +
3470 +        fs.add(incomplete.applyToEitherAsync(incomplete, z -> z, e));
3471 +        fs.add(incomplete.acceptEitherAsync(incomplete, z -> {}, e));
3472 +        fs.add(incomplete.runAfterEitherAsync(incomplete, () -> {}, e));
3473 +
3474 +        fs.add(incomplete.thenComposeAsync(z -> null, e));
3475 +        fs.add(incomplete.whenCompleteAsync((z, t) -> {}, e));
3476 +        fs.add(incomplete.handleAsync((z, t) -> null, e));
3477 +
3478 +        fs.add(complete.thenCombineAsync(incomplete, (x, y) -> x, e));
3479 +        fs.add(incomplete.thenCombineAsync(complete, (x, y) -> x, e));
3480 +
3481 +        fs.add(complete.thenAcceptBothAsync(incomplete, (x, y) -> {}, e));
3482 +        fs.add(incomplete.thenAcceptBothAsync(complete, (x, y) -> {}, e));
3483 +
3484 +        fs.add(complete.runAfterBothAsync(incomplete, () -> {}, e));
3485 +        fs.add(incomplete.runAfterBothAsync(complete, () -> {}, e));
3486 +
3487 +        for (CompletableFuture<?> future : fs)
3488 +            checkIncomplete(future);
3489 +
3490 +        for (CompletableFuture<?> future : fs)
3491 +            future.complete(null);
3492 +
3493 +        incomplete.complete(v);
3494 +
3495 +        for (CompletableFuture<?> future : fs)
3496 +            checkCompletedNormally(future, null);
3497 +
3498 +        assertEquals(0, e.count.get());
3499 +    }}
3500 +
3501 +    /**
3502       * toCompletableFuture returns this CompletableFuture.
3503       */
3504      public void testToCompletableFuture() {
# Line 3038 | Line 3506 | public class CompletableFutureTest exten
3506          assertSame(f, f.toCompletableFuture());
3507      }
3508  
3509 +    // jdk9
3510 +
3511      /**
3512 <     * whenComplete action executes on normal completion, propagating
3043 <     * source result.
3512 >     * newIncompleteFuture returns an incomplete CompletableFuture
3513       */
3514 <    public void testWhenComplete1() {
3515 <        final AtomicInteger a = new AtomicInteger();
3514 >    public void testNewIncompleteFuture() {
3515 >        for (Integer v1 : new Integer[] { 1, null })
3516 >    {
3517          CompletableFuture<Integer> f = new CompletableFuture<>();
3518 <        CompletableFuture<Integer> g =
3519 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3520 <        f.complete(three);
3521 <        checkCompletedNormally(f, three);
3522 <        checkCompletedNormally(g, three);
3523 <        assertEquals(a.get(), 1);
3518 >        CompletableFuture<Integer> g = f.newIncompleteFuture();
3519 >        checkIncomplete(f);
3520 >        checkIncomplete(g);
3521 >        f.complete(v1);
3522 >        checkCompletedNormally(f, v1);
3523 >        checkIncomplete(g);
3524 >        g.complete(v1);
3525 >        checkCompletedNormally(g, v1);
3526 >        assertSame(g.getClass(), CompletableFuture.class);
3527 >    }}
3528 >
3529 >    /**
3530 >     * completedStage returns a completed CompletionStage
3531 >     */
3532 >    public void testCompletedStage() {
3533 >        AtomicInteger x = new AtomicInteger(0);
3534 >        AtomicReference<Throwable> r = new AtomicReference<>();
3535 >        CompletionStage<Integer> f = CompletableFuture.completedStage(1);
3536 >        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3537 >        assertEquals(x.get(), 1);
3538 >        assertNull(r.get());
3539      }
3540  
3541      /**
3542 <     * whenComplete action executes on exceptional completion, propagating
3543 <     * source result.
3542 >     * defaultExecutor by default returns the commonPool if
3543 >     * it supports more than one thread.
3544       */
3545 <    public void testWhenComplete2() {
3061 <        final AtomicInteger a = new AtomicInteger();
3545 >    public void testDefaultExecutor() {
3546          CompletableFuture<Integer> f = new CompletableFuture<>();
3547 <        CompletableFuture<Integer> g =
3548 <            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3549 <        f.completeExceptionally(new CFException());
3550 <        assertTrue(f.isCompletedExceptionally());
3551 <        assertTrue(g.isCompletedExceptionally());
3552 <        assertEquals(a.get(), 1);
3547 >        Executor e = f.defaultExecutor();
3548 >        Executor c = ForkJoinPool.commonPool();
3549 >        if (ForkJoinPool.getCommonPoolParallelism() > 1)
3550 >            assertSame(e, c);
3551 >        else
3552 >            assertNotSame(e, c);
3553      }
3554  
3555      /**
3556 <     * If a whenComplete action throws an exception when triggered by
3557 <     * a normal completion, it completes exceptionally
3556 >     * failedFuture returns a CompletableFuture completed
3557 >     * exceptionally with the given Exception
3558 >     */
3559 >    public void testFailedFuture() {
3560 >        CFException ex = new CFException();
3561 >        CompletableFuture<Integer> f = CompletableFuture.failedFuture(ex);
3562 >        checkCompletedExceptionally(f, ex);
3563 >    }
3564 >
3565 >    /**
3566 >     * failedFuture(null) throws NPE
3567 >     */
3568 >    public void testFailedFuture_null() {
3569 >        try {
3570 >            CompletableFuture<Integer> f = CompletableFuture.failedFuture(null);
3571 >            shouldThrow();
3572 >        } catch (NullPointerException success) {}
3573 >    }
3574 >
3575 >    /**
3576 >     * copy returns a CompletableFuture that is completed normally,
3577 >     * with the same value, when source is.
3578       */
3579 <    public void testWhenComplete3() {
3579 >    public void testCopy_normalCompletion() {
3580 >        for (boolean createIncomplete : new boolean[] { true, false })
3581 >        for (Integer v1 : new Integer[] { 1, null })
3582 >    {
3583          CompletableFuture<Integer> f = new CompletableFuture<>();
3584 <        CompletableFuture<Integer> g =
3585 <            f.whenComplete((Integer x, Throwable t) ->
3586 <                           { throw new CFException(); } );
3587 <        f.complete(three);
3588 <        checkCompletedNormally(f, three);
3589 <        assertTrue(g.isCompletedExceptionally());
3590 <        checkCompletedWithWrappedCFException(g);
3584 >        if (!createIncomplete) assertTrue(f.complete(v1));
3585 >        CompletableFuture<Integer> g = f.copy();
3586 >        if (createIncomplete) {
3587 >            checkIncomplete(f);
3588 >            checkIncomplete(g);
3589 >            assertTrue(f.complete(v1));
3590 >        }
3591 >        checkCompletedNormally(f, v1);
3592 >        checkCompletedNormally(g, v1);
3593 >    }}
3594 >
3595 >    /**
3596 >     * copy returns a CompletableFuture that is completed exceptionally
3597 >     * when source is.
3598 >     */
3599 >    public void testCopy_exceptionalCompletion() {
3600 >        for (boolean createIncomplete : new boolean[] { true, false })
3601 >    {
3602 >        CFException ex = new CFException();
3603 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3604 >        if (!createIncomplete) f.completeExceptionally(ex);
3605 >        CompletableFuture<Integer> g = f.copy();
3606 >        if (createIncomplete) {
3607 >            checkIncomplete(f);
3608 >            checkIncomplete(g);
3609 >            f.completeExceptionally(ex);
3610 >        }
3611 >        checkCompletedExceptionally(f, ex);
3612 >        checkCompletedWithWrappedException(g, ex);
3613 >    }}
3614 >
3615 >    /**
3616 >     * Completion of a copy does not complete its source.
3617 >     */
3618 >    public void testCopy_oneWayPropagation() {
3619 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3620 >        assertTrue(f.copy().complete(1));
3621 >        assertTrue(f.copy().complete(null));
3622 >        assertTrue(f.copy().cancel(true));
3623 >        assertTrue(f.copy().cancel(false));
3624 >        assertTrue(f.copy().completeExceptionally(new CFException()));
3625 >        checkIncomplete(f);
3626      }
3627  
3628      /**
3629 <     * whenCompleteAsync action executes on normal completion, propagating
3630 <     * source result.
3629 >     * minimalCompletionStage returns a CompletableFuture that is
3630 >     * completed normally, with the same value, when source is.
3631       */
3632 <    public void testWhenCompleteAsync1() {
3091 <        final AtomicInteger a = new AtomicInteger();
3632 >    public void testMinimalCompletionStage() {
3633          CompletableFuture<Integer> f = new CompletableFuture<>();
3634 <        CompletableFuture<Integer> g =
3635 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3636 <        f.complete(three);
3637 <        checkCompletedNormally(f, three);
3638 <        checkCompletedNormally(g, three);
3639 <        assertEquals(a.get(), 1);
3634 >        CompletionStage<Integer> g = f.minimalCompletionStage();
3635 >        AtomicInteger x = new AtomicInteger(0);
3636 >        AtomicReference<Throwable> r = new AtomicReference<>();
3637 >        checkIncomplete(f);
3638 >        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3639 >        f.complete(1);
3640 >        checkCompletedNormally(f, 1);
3641 >        assertEquals(x.get(), 1);
3642 >        assertNull(r.get());
3643      }
3644  
3645      /**
3646 <     * whenCompleteAsync action executes on exceptional completion, propagating
3647 <     * source result.
3646 >     * minimalCompletionStage returns a CompletableFuture that is
3647 >     * completed exceptionally when source is.
3648       */
3649 <    public void testWhenCompleteAsync2() {
3106 <        final AtomicInteger a = new AtomicInteger();
3649 >    public void testMinimalCompletionStage2() {
3650          CompletableFuture<Integer> f = new CompletableFuture<>();
3651 <        CompletableFuture<Integer> g =
3652 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3653 <        f.completeExceptionally(new CFException());
3654 <        checkCompletedWithWrappedCFException(f);
3655 <        checkCompletedWithWrappedCFException(g);
3651 >        CompletionStage<Integer> g = f.minimalCompletionStage();
3652 >        AtomicInteger x = new AtomicInteger(0);
3653 >        AtomicReference<Throwable> r = new AtomicReference<>();
3654 >        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3655 >        checkIncomplete(f);
3656 >        CFException ex = new CFException();
3657 >        f.completeExceptionally(ex);
3658 >        checkCompletedExceptionally(f, ex);
3659 >        assertEquals(x.get(), 0);
3660 >        assertEquals(r.get().getCause(), ex);
3661 >    }
3662 >
3663 >    /**
3664 >     * failedStage returns a CompletionStage completed
3665 >     * exceptionally with the given Exception
3666 >     */
3667 >    public void testFailedStage() {
3668 >        CFException ex = new CFException();
3669 >        CompletionStage<Integer> f = CompletableFuture.failedStage(ex);
3670 >        AtomicInteger x = new AtomicInteger(0);
3671 >        AtomicReference<Throwable> r = new AtomicReference<>();
3672 >        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3673 >        assertEquals(x.get(), 0);
3674 >        assertEquals(r.get(), ex);
3675      }
3676  
3677      /**
3678 <     * If a whenCompleteAsync action throws an exception when
3117 <     * triggered by a normal completion, it completes exceptionally
3678 >     * completeAsync completes with value of given supplier
3679       */
3680 <    public void testWhenCompleteAsync3() {
3680 >    public void testCompleteAsync() {
3681 >        for (Integer v1 : new Integer[] { 1, null })
3682 >    {
3683          CompletableFuture<Integer> f = new CompletableFuture<>();
3684 <        CompletableFuture<Integer> g =
3685 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3686 <                           { throw new CFException(); } );
3687 <        f.complete(three);
3688 <        checkCompletedNormally(f, three);
3689 <        checkCompletedWithWrappedCFException(g);
3684 >        f.completeAsync(() -> v1);
3685 >        f.join();
3686 >        checkCompletedNormally(f, v1);
3687 >    }}
3688 >
3689 >    /**
3690 >     * completeAsync completes exceptionally if given supplier throws
3691 >     */
3692 >    public void testCompleteAsync2() {
3693 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3694 >        CFException ex = new CFException();
3695 >        f.completeAsync(() -> { throw ex; });
3696 >        try {
3697 >            f.join();
3698 >            shouldThrow();
3699 >        } catch (CompletionException success) {}
3700 >        checkCompletedWithWrappedException(f, ex);
3701      }
3702  
3703      /**
3704 <     * whenCompleteAsync action executes on normal completion, propagating
3131 <     * source result.
3704 >     * completeAsync with given executor completes with value of given supplier
3705       */
3706 <    public void testWhenCompleteAsync1e() {
3707 <        final AtomicInteger a = new AtomicInteger();
3708 <        ThreadExecutor exec = new ThreadExecutor();
3706 >    public void testCompleteAsync3() {
3707 >        for (Integer v1 : new Integer[] { 1, null })
3708 >    {
3709          CompletableFuture<Integer> f = new CompletableFuture<>();
3710 <        CompletableFuture<Integer> g =
3711 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3712 <                                exec);
3713 <        f.complete(three);
3714 <        checkCompletedNormally(f, three);
3715 <        checkCompletedNormally(g, three);
3716 <        assertEquals(a.get(), 1);
3710 >        ThreadExecutor executor = new ThreadExecutor();
3711 >        f.completeAsync(() -> v1, executor);
3712 >        assertSame(v1, f.join());
3713 >        checkCompletedNormally(f, v1);
3714 >        assertEquals(1, executor.count.get());
3715 >    }}
3716 >
3717 >    /**
3718 >     * completeAsync with given executor completes exceptionally if
3719 >     * given supplier throws
3720 >     */
3721 >    public void testCompleteAsync4() {
3722 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3723 >        CFException ex = new CFException();
3724 >        ThreadExecutor executor = new ThreadExecutor();
3725 >        f.completeAsync(() -> { throw ex; }, executor);
3726 >        try {
3727 >            f.join();
3728 >            shouldThrow();
3729 >        } catch (CompletionException success) {}
3730 >        checkCompletedWithWrappedException(f, ex);
3731 >        assertEquals(1, executor.count.get());
3732      }
3733  
3734      /**
3735 <     * whenCompleteAsync action executes on exceptional completion, propagating
3148 <     * source result.
3735 >     * orTimeout completes with TimeoutException if not complete
3736       */
3737 <    public void testWhenCompleteAsync2e() {
3738 <        final AtomicInteger a = new AtomicInteger();
3152 <        ThreadExecutor exec = new ThreadExecutor();
3737 >    public void testOrTimeout_timesOut() {
3738 >        long timeoutMillis = timeoutMillis();
3739          CompletableFuture<Integer> f = new CompletableFuture<>();
3740 <        CompletableFuture<Integer> g =
3741 <            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3742 <                                exec);
3743 <        f.completeExceptionally(new CFException());
3158 <        checkCompletedWithWrappedCFException(f);
3159 <        checkCompletedWithWrappedCFException(g);
3740 >        long startTime = System.nanoTime();
3741 >        assertSame(f, f.orTimeout(timeoutMillis, MILLISECONDS));
3742 >        checkCompletedWithTimeoutException(f);
3743 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
3744      }
3745  
3746      /**
3747 <     * If a whenCompleteAsync action throws an exception when triggered
3164 <     * by a normal completion, it completes exceptionally
3747 >     * orTimeout completes normally if completed before timeout
3748       */
3749 <    public void testWhenCompleteAsync3e() {
3750 <        ThreadExecutor exec = new ThreadExecutor();
3749 >    public void testOrTimeout_completed() {
3750 >        for (Integer v1 : new Integer[] { 1, null })
3751 >    {
3752          CompletableFuture<Integer> f = new CompletableFuture<>();
3753 +        CompletableFuture<Integer> g = new CompletableFuture<>();
3754 +        long startTime = System.nanoTime();
3755 +        f.complete(v1);
3756 +        assertSame(f, f.orTimeout(LONG_DELAY_MS, MILLISECONDS));
3757 +        assertSame(g, g.orTimeout(LONG_DELAY_MS, MILLISECONDS));
3758 +        g.complete(v1);
3759 +        checkCompletedNormally(f, v1);
3760 +        checkCompletedNormally(g, v1);
3761 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
3762 +    }}
3763 +
3764 +    /**
3765 +     * completeOnTimeout completes with given value if not complete
3766 +     */
3767 +    public void testCompleteOnTimeout_timesOut() {
3768 +        testInParallel(() -> testCompleteOnTimeout_timesOut(42),
3769 +                       () -> testCompleteOnTimeout_timesOut(null));
3770 +    }
3771 +
3772 +    /**
3773 +     * completeOnTimeout completes with given value if not complete
3774 +     */
3775 +    public void testCompleteOnTimeout_timesOut(Integer v) {
3776 +        long timeoutMillis = timeoutMillis();
3777 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3778 +        long startTime = System.nanoTime();
3779 +        assertSame(f, f.completeOnTimeout(v, timeoutMillis, MILLISECONDS));
3780 +        assertSame(v, f.join());
3781 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
3782 +        f.complete(99);         // should have no effect
3783 +        checkCompletedNormally(f, v);
3784 +    }
3785 +
3786 +    /**
3787 +     * completeOnTimeout has no effect if completed within timeout
3788 +     */
3789 +    public void testCompleteOnTimeout_completed() {
3790 +        for (Integer v1 : new Integer[] { 1, null })
3791 +    {
3792 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3793 +        CompletableFuture<Integer> g = new CompletableFuture<>();
3794 +        long startTime = System.nanoTime();
3795 +        f.complete(v1);
3796 +        assertSame(f, f.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS));
3797 +        assertSame(g, g.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS));
3798 +        g.complete(v1);
3799 +        checkCompletedNormally(f, v1);
3800 +        checkCompletedNormally(g, v1);
3801 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
3802 +    }}
3803 +
3804 +    /**
3805 +     * delayedExecutor returns an executor that delays submission
3806 +     */
3807 +    public void testDelayedExecutor() {
3808 +        testInParallel(() -> testDelayedExecutor(null, null),
3809 +                       () -> testDelayedExecutor(null, 1),
3810 +                       () -> testDelayedExecutor(new ThreadExecutor(), 1),
3811 +                       () -> testDelayedExecutor(new ThreadExecutor(), 1));
3812 +    }
3813 +
3814 +    public void testDelayedExecutor(Executor executor, Integer v) throws Exception {
3815 +        long timeoutMillis = timeoutMillis();
3816 +        // Use an "unreasonably long" long timeout to catch lingering threads
3817 +        long longTimeoutMillis = 1000 * 60 * 60 * 24;
3818 +        final Executor delayer, longDelayer;
3819 +        if (executor == null) {
3820 +            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS);
3821 +            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS);
3822 +        } else {
3823 +            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS, executor);
3824 +            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS, executor);
3825 +        }
3826 +        long startTime = System.nanoTime();
3827 +        CompletableFuture<Integer> f =
3828 +            CompletableFuture.supplyAsync(() -> v, delayer);
3829          CompletableFuture<Integer> g =
3830 <            f.whenCompleteAsync((Integer x, Throwable t) ->
3831 <                                { throw new CFException(); },
3832 <                                exec);
3833 <        f.complete(three);
3834 <        checkCompletedNormally(f, three);
3835 <        checkCompletedWithWrappedCFException(g);
3830 >            CompletableFuture.supplyAsync(() -> v, longDelayer);
3831 >
3832 >        assertNull(g.getNow(null));
3833 >
3834 >        assertSame(v, f.get(LONG_DELAY_MS, MILLISECONDS));
3835 >        long millisElapsed = millisElapsedSince(startTime);
3836 >        assertTrue(millisElapsed >= timeoutMillis);
3837 >        assertTrue(millisElapsed < LONG_DELAY_MS / 2);
3838 >
3839 >        checkCompletedNormally(f, v);
3840 >
3841 >        checkIncomplete(g);
3842 >        assertTrue(g.cancel(true));
3843 >    }
3844 >
3845 >    //--- tests of implementation details; not part of official tck ---
3846 >
3847 >    Object resultOf(CompletableFuture<?> f) {
3848 >        SecurityManager sm = System.getSecurityManager();
3849 >        if (sm != null) {
3850 >            try {
3851 >                System.setSecurityManager(null);
3852 >            } catch (SecurityException giveUp) {
3853 >                return "Reflection not available";
3854 >            }
3855 >        }
3856 >
3857 >        try {
3858 >            java.lang.reflect.Field resultField
3859 >                = CompletableFuture.class.getDeclaredField("result");
3860 >            resultField.setAccessible(true);
3861 >            return resultField.get(f);
3862 >        } catch (Throwable t) {
3863 >            throw new AssertionError(t);
3864 >        } finally {
3865 >            if (sm != null) System.setSecurityManager(sm);
3866 >        }
3867      }
3868  
3869 +    public void testExceptionPropagationReusesResultObject() {
3870 +        if (!testImplementationDetails) return;
3871 +        for (ExecutionMode m : ExecutionMode.values())
3872 +    {
3873 +        final CFException ex = new CFException();
3874 +        final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3875 +        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3876 +
3877 +        final Runnable noopRunnable = new Noop(m);
3878 +        final Consumer<Integer> noopConsumer = new NoopConsumer(m);
3879 +        final Function<Integer, Integer> incFunction = new IncFunction(m);
3880 +
3881 +        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3882 +            = new ArrayList<>();
3883 +
3884 +        funs.add(y -> m.thenRun(y, noopRunnable));
3885 +        funs.add(y -> m.thenAccept(y, noopConsumer));
3886 +        funs.add(y -> m.thenApply(y, incFunction));
3887 +
3888 +        funs.add(y -> m.runAfterEither(y, incomplete, noopRunnable));
3889 +        funs.add(y -> m.acceptEither(y, incomplete, noopConsumer));
3890 +        funs.add(y -> m.applyToEither(y, incomplete, incFunction));
3891 +
3892 +        funs.add(y -> m.runAfterBoth(y, v42, noopRunnable));
3893 +        funs.add(y -> m.runAfterBoth(v42, y, noopRunnable));
3894 +        funs.add(y -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3895 +        funs.add(y -> m.thenAcceptBoth(v42, y, new SubtractAction(m)));
3896 +        funs.add(y -> m.thenCombine(y, v42, new SubtractFunction(m)));
3897 +        funs.add(y -> m.thenCombine(v42, y, new SubtractFunction(m)));
3898 +
3899 +        funs.add(y -> m.whenComplete(y, (Integer r, Throwable t) -> {}));
3900 +
3901 +        funs.add(y -> m.thenCompose(y, new CompletableFutureInc(m)));
3902 +
3903 +        funs.add(y -> CompletableFuture.allOf(y));
3904 +        funs.add(y -> CompletableFuture.allOf(y, v42));
3905 +        funs.add(y -> CompletableFuture.allOf(v42, y));
3906 +        funs.add(y -> CompletableFuture.anyOf(y));
3907 +        funs.add(y -> CompletableFuture.anyOf(y, incomplete));
3908 +        funs.add(y -> CompletableFuture.anyOf(incomplete, y));
3909 +
3910 +        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3911 +                 fun : funs) {
3912 +            CompletableFuture<Integer> f = new CompletableFuture<>();
3913 +            f.completeExceptionally(ex);
3914 +            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3915 +            checkCompletedWithWrappedException(src, ex);
3916 +            CompletableFuture<?> dep = fun.apply(src);
3917 +            checkCompletedWithWrappedException(dep, ex);
3918 +            assertSame(resultOf(src), resultOf(dep));
3919 +        }
3920 +
3921 +        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3922 +                 fun : funs) {
3923 +            CompletableFuture<Integer> f = new CompletableFuture<>();
3924 +            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3925 +            CompletableFuture<?> dep = fun.apply(src);
3926 +            f.completeExceptionally(ex);
3927 +            checkCompletedWithWrappedException(src, ex);
3928 +            checkCompletedWithWrappedException(dep, ex);
3929 +            assertSame(resultOf(src), resultOf(dep));
3930 +        }
3931 +
3932 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3933 +        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3934 +                 fun : funs) {
3935 +            CompletableFuture<Integer> f = new CompletableFuture<>();
3936 +            f.cancel(mayInterruptIfRunning);
3937 +            checkCancelled(f);
3938 +            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3939 +            checkCompletedWithWrappedCancellationException(src);
3940 +            CompletableFuture<?> dep = fun.apply(src);
3941 +            checkCompletedWithWrappedCancellationException(dep);
3942 +            assertSame(resultOf(src), resultOf(dep));
3943 +        }
3944 +
3945 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3946 +        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3947 +                 fun : funs) {
3948 +            CompletableFuture<Integer> f = new CompletableFuture<>();
3949 +            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3950 +            CompletableFuture<?> dep = fun.apply(src);
3951 +            f.cancel(mayInterruptIfRunning);
3952 +            checkCancelled(f);
3953 +            checkCompletedWithWrappedCancellationException(src);
3954 +            checkCompletedWithWrappedCancellationException(dep);
3955 +            assertSame(resultOf(src), resultOf(dep));
3956 +        }
3957 +    }}
3958 +
3959      /**
3960 <     * handleAsync action completes normally with function value on
3180 <     * either normal or exceptional completion of source
3960 >     * Minimal completion stages throw UOE for most non-CompletionStage methods
3961       */
3962 <    public void testHandleAsync() {
3963 <        CompletableFuture<Integer> f, g;
3964 <        IntegerHandler r;
3962 >    public void testMinimalCompletionStage_minimality() {
3963 >        if (!testImplementationDetails) return;
3964 >        Function<Method, String> toSignature =
3965 >            method -> method.getName() + Arrays.toString(method.getParameterTypes());
3966 >        Predicate<Method> isNotStatic =
3967 >            method -> (method.getModifiers() & Modifier.STATIC) == 0;
3968 >        List<Method> minimalMethods =
3969 >            Stream.of(Object.class, CompletionStage.class)
3970 >            .flatMap(klazz -> Stream.of(klazz.getMethods()))
3971 >            .filter(isNotStatic)
3972 >            .collect(Collectors.toList());
3973 >        // Methods from CompletableFuture permitted NOT to throw UOE
3974 >        String[] signatureWhitelist = {
3975 >            "newIncompleteFuture[]",
3976 >            "defaultExecutor[]",
3977 >            "minimalCompletionStage[]",
3978 >            "copy[]",
3979 >        };
3980 >        Set<String> permittedMethodSignatures =
3981 >            Stream.concat(minimalMethods.stream().map(toSignature),
3982 >                          Stream.of(signatureWhitelist))
3983 >            .collect(Collectors.toSet());
3984 >        List<Method> allMethods = Stream.of(CompletableFuture.class.getMethods())
3985 >            .filter(isNotStatic)
3986 >            .filter(method -> !permittedMethodSignatures.contains(toSignature.apply(method)))
3987 >            .collect(Collectors.toList());
3988 >
3989 >        List<CompletionStage<Integer>> stages = new ArrayList<>();
3990 >        CompletionStage<Integer> min =
3991 >            new CompletableFuture<Integer>().minimalCompletionStage();
3992 >        stages.add(min);
3993 >        stages.add(min.thenApply(x -> x));
3994 >        stages.add(CompletableFuture.completedStage(1));
3995 >        stages.add(CompletableFuture.failedStage(new CFException()));
3996 >
3997 >        List<Method> bugs = new ArrayList<>();
3998 >        for (Method method : allMethods) {
3999 >            Class<?>[] parameterTypes = method.getParameterTypes();
4000 >            Object[] args = new Object[parameterTypes.length];
4001 >            // Manufacture boxed primitives for primitive params
4002 >            for (int i = 0; i < args.length; i++) {
4003 >                Class<?> type = parameterTypes[i];
4004 >                if (parameterTypes[i] == boolean.class)
4005 >                    args[i] = false;
4006 >                else if (parameterTypes[i] == int.class)
4007 >                    args[i] = 0;
4008 >                else if (parameterTypes[i] == long.class)
4009 >                    args[i] = 0L;
4010 >            }
4011 >            for (CompletionStage<Integer> stage : stages) {
4012 >                try {
4013 >                    method.invoke(stage, args);
4014 >                    bugs.add(method);
4015 >                }
4016 >                catch (java.lang.reflect.InvocationTargetException expected) {
4017 >                    if (! (expected.getCause() instanceof UnsupportedOperationException)) {
4018 >                        bugs.add(method);
4019 >                        // expected.getCause().printStackTrace();
4020 >                    }
4021 >                }
4022 >                catch (ReflectiveOperationException bad) { throw new Error(bad); }
4023 >            }
4024 >        }
4025 >        if (!bugs.isEmpty())
4026 >            throw new Error("Methods did not throw UOE: " + bugs);
4027 >    }
4028  
4029 <        f = new CompletableFuture<>();
4030 <        g = f.handleAsync(r = new IntegerHandler());
4031 <        assertFalse(r.ran);
4032 <        f.completeExceptionally(new CFException());
4033 <        checkCompletedWithWrappedCFException(f);
4034 <        checkCompletedNormally(g, three);
4035 <        assertTrue(r.ran);
4029 >    /**
4030 >     * minimalStage.toCompletableFuture() returns a CompletableFuture that
4031 >     * is completed normally, with the same value, when source is.
4032 >     */
4033 >    public void testMinimalCompletionStage_toCompletableFuture_normalCompletion() {
4034 >        for (boolean createIncomplete : new boolean[] { true, false })
4035 >        for (Integer v1 : new Integer[] { 1, null })
4036 >    {
4037 >        CompletableFuture<Integer> f = new CompletableFuture<>();
4038 >        CompletionStage<Integer> minimal = f.minimalCompletionStage();
4039 >        if (!createIncomplete) assertTrue(f.complete(v1));
4040 >        CompletableFuture<Integer> g = minimal.toCompletableFuture();
4041 >        if (createIncomplete) {
4042 >            checkIncomplete(f);
4043 >            checkIncomplete(g);
4044 >            assertTrue(f.complete(v1));
4045 >        }
4046 >        checkCompletedNormally(f, v1);
4047 >        checkCompletedNormally(g, v1);
4048 >    }}
4049 >
4050 >    /**
4051 >     * minimalStage.toCompletableFuture() returns a CompletableFuture that
4052 >     * is completed exceptionally when source is.
4053 >     */
4054 >    public void testMinimalCompletionStage_toCompletableFuture_exceptionalCompletion() {
4055 >        for (boolean createIncomplete : new boolean[] { true, false })
4056 >    {
4057 >        CFException ex = new CFException();
4058 >        CompletableFuture<Integer> f = new CompletableFuture<>();
4059 >        CompletionStage<Integer> minimal = f.minimalCompletionStage();
4060 >        if (!createIncomplete) f.completeExceptionally(ex);
4061 >        CompletableFuture<Integer> g = minimal.toCompletableFuture();
4062 >        if (createIncomplete) {
4063 >            checkIncomplete(f);
4064 >            checkIncomplete(g);
4065 >            f.completeExceptionally(ex);
4066 >        }
4067 >        checkCompletedExceptionally(f, ex);
4068 >        checkCompletedWithWrappedException(g, ex);
4069 >    }}
4070  
4071 <        f = new CompletableFuture<>();
4072 <        g = f.handleAsync(r = new IntegerHandler());
4073 <        assertFalse(r.ran);
4074 <        f.completeExceptionally(new CFException());
4075 <        checkCompletedWithWrappedCFException(f);
4076 <        checkCompletedNormally(g, three);
4077 <        assertTrue(r.ran);
4071 >    /**
4072 >     * minimalStage.toCompletableFuture() gives mutable CompletableFuture
4073 >     */
4074 >    public void testMinimalCompletionStage_toCompletableFuture_mutable() {
4075 >        for (Integer v1 : new Integer[] { 1, null })
4076 >    {
4077 >        CompletableFuture<Integer> f = new CompletableFuture<>();
4078 >        CompletionStage minimal = f.minimalCompletionStage();
4079 >        CompletableFuture<Integer> g = minimal.toCompletableFuture();
4080 >        assertTrue(g.complete(v1));
4081 >        checkCompletedNormally(g, v1);
4082 >        checkIncomplete(f);
4083 >        checkIncomplete(minimal.toCompletableFuture());
4084 >    }}
4085  
4086 <        f = new CompletableFuture<>();
4087 <        g = f.handleAsync(r = new IntegerHandler());
4088 <        assertFalse(r.ran);
4089 <        f.complete(one);
4090 <        checkCompletedNormally(f, one);
4091 <        checkCompletedNormally(g, two);
4092 <        assertTrue(r.ran);
4086 >    /**
4087 >     * minimalStage.toCompletableFuture().join() awaits completion
4088 >     */
4089 >    public void testMinimalCompletionStage_toCompletableFuture_join() throws Exception {
4090 >        for (boolean createIncomplete : new boolean[] { true, false })
4091 >        for (Integer v1 : new Integer[] { 1, null })
4092 >    {
4093 >        CompletableFuture<Integer> f = new CompletableFuture<>();
4094 >        if (!createIncomplete) assertTrue(f.complete(v1));
4095 >        CompletionStage<Integer> minimal = f.minimalCompletionStage();
4096 >        if (createIncomplete) assertTrue(f.complete(v1));
4097 >        assertEquals(v1, minimal.toCompletableFuture().join());
4098 >        assertEquals(v1, minimal.toCompletableFuture().get());
4099 >        checkCompletedNormally(minimal.toCompletableFuture(), v1);
4100 >    }}
4101 >
4102 >    /**
4103 >     * Completion of a toCompletableFuture copy of a minimal stage
4104 >     * does not complete its source.
4105 >     */
4106 >    public void testMinimalCompletionStage_toCompletableFuture_oneWayPropagation() {
4107 >        CompletableFuture<Integer> f = new CompletableFuture<>();
4108 >        CompletionStage<Integer> g = f.minimalCompletionStage();
4109 >        assertTrue(g.toCompletableFuture().complete(1));
4110 >        assertTrue(g.toCompletableFuture().complete(null));
4111 >        assertTrue(g.toCompletableFuture().cancel(true));
4112 >        assertTrue(g.toCompletableFuture().cancel(false));
4113 >        assertTrue(g.toCompletableFuture().completeExceptionally(new CFException()));
4114 >        checkIncomplete(g.toCompletableFuture());
4115 >        f.complete(1);
4116 >        checkCompletedNormally(g.toCompletableFuture(), 1);
4117 >    }
4118  
4119 <        f = new CompletableFuture<>();
4120 <        g = f.handleAsync(r = new IntegerHandler());
4121 <        assertFalse(r.ran);
4122 <        f.complete(one);
4123 <        checkCompletedNormally(f, one);
4124 <        checkCompletedNormally(g, two);
4125 <        assertTrue(r.ran);
4119 >    /** Demo utility method for external reliable toCompletableFuture */
4120 >    static <T> CompletableFuture<T> toCompletableFuture(CompletionStage<T> stage) {
4121 >        CompletableFuture<T> f = new CompletableFuture<>();
4122 >        stage.handle((T t, Throwable ex) -> {
4123 >                         if (ex != null) f.completeExceptionally(ex);
4124 >                         else f.complete(t);
4125 >                         return null;
4126 >                     });
4127 >        return f;
4128 >    }
4129 >
4130 >    /** Demo utility method to join a CompletionStage */
4131 >    static <T> T join(CompletionStage<T> stage) {
4132 >        return toCompletableFuture(stage).join();
4133      }
4134  
4135      /**
4136 <     * handleAsync action with Executor completes normally with
3221 <     * function value on either normal or exceptional completion of
3222 <     * source
4136 >     * Joining a minimal stage "by hand" works
4137       */
4138 <    public void testHandleAsync2() {
4139 <        CompletableFuture<Integer> f, g;
4140 <        ThreadExecutor exec = new ThreadExecutor();
4141 <        IntegerHandler r;
4138 >    public void testMinimalCompletionStage_join_by_hand() {
4139 >        for (boolean createIncomplete : new boolean[] { true, false })
4140 >        for (Integer v1 : new Integer[] { 1, null })
4141 >    {
4142 >        CompletableFuture<Integer> f = new CompletableFuture<>();
4143 >        CompletionStage<Integer> minimal = f.minimalCompletionStage();
4144 >        CompletableFuture<Integer> g = new CompletableFuture<>();
4145 >        if (!createIncomplete) assertTrue(f.complete(v1));
4146 >        minimal.thenAccept(x -> g.complete(x));
4147 >        if (createIncomplete) assertTrue(f.complete(v1));
4148 >        g.join();
4149 >        checkCompletedNormally(g, v1);
4150 >        checkCompletedNormally(f, v1);
4151 >        assertEquals(v1, join(minimal));
4152 >    }}
4153 >
4154 >    static class Monad {
4155 >        static class ZeroException extends RuntimeException {
4156 >            public ZeroException() { super("monadic zero"); }
4157 >        }
4158 >        // "return", "unit"
4159 >        static <T> CompletableFuture<T> unit(T value) {
4160 >            return completedFuture(value);
4161 >        }
4162 >        // monadic zero ?
4163 >        static <T> CompletableFuture<T> zero() {
4164 >            return failedFuture(new ZeroException());
4165 >        }
4166 >        // >=>
4167 >        static <T,U,V> Function<T, CompletableFuture<V>> compose
4168 >            (Function<T, CompletableFuture<U>> f,
4169 >             Function<U, CompletableFuture<V>> g) {
4170 >            return x -> f.apply(x).thenCompose(g);
4171 >        }
4172  
4173 <        f = new CompletableFuture<>();
4174 <        g = f.handleAsync(r = new IntegerHandler(), exec);
4175 <        assertFalse(r.ran);
4176 <        f.completeExceptionally(new CFException());
4177 <        checkCompletedWithWrappedCFException(f);
4178 <        checkCompletedNormally(g, three);
4179 <        assertTrue(r.ran);
4173 >        static void assertZero(CompletableFuture<?> f) {
4174 >            try {
4175 >                f.getNow(null);
4176 >                throw new AssertionFailedError("should throw");
4177 >            } catch (CompletionException success) {
4178 >                assertTrue(success.getCause() instanceof ZeroException);
4179 >            }
4180 >        }
4181  
4182 <        f = new CompletableFuture<>();
4183 <        g = f.handleAsync(r = new IntegerHandler(), exec);
4184 <        assertFalse(r.ran);
4185 <        f.completeExceptionally(new CFException());
4186 <        checkCompletedWithWrappedCFException(f);
4187 <        checkCompletedNormally(g, three);
4188 <        assertTrue(r.ran);
4182 >        static <T> void assertFutureEquals(CompletableFuture<T> f,
4183 >                                           CompletableFuture<T> g) {
4184 >            T fval = null, gval = null;
4185 >            Throwable fex = null, gex = null;
4186 >
4187 >            try { fval = f.get(); }
4188 >            catch (ExecutionException ex) { fex = ex.getCause(); }
4189 >            catch (Throwable ex) { fex = ex; }
4190 >
4191 >            try { gval = g.get(); }
4192 >            catch (ExecutionException ex) { gex = ex.getCause(); }
4193 >            catch (Throwable ex) { gex = ex; }
4194 >
4195 >            if (fex != null || gex != null)
4196 >                assertSame(fex.getClass(), gex.getClass());
4197 >            else
4198 >                assertEquals(fval, gval);
4199 >        }
4200  
4201 <        f = new CompletableFuture<>();
4202 <        g = f.handleAsync(r = new IntegerHandler(), exec);
4203 <        assertFalse(r.ran);
3248 <        f.complete(one);
3249 <        checkCompletedNormally(f, one);
3250 <        checkCompletedNormally(g, two);
3251 <        assertTrue(r.ran);
4201 >        static class PlusFuture<T> extends CompletableFuture<T> {
4202 >            AtomicReference<Throwable> firstFailure = new AtomicReference<>(null);
4203 >        }
4204  
4205 <        f = new CompletableFuture<>();
4206 <        g = f.handleAsync(r = new IntegerHandler(), exec);
4207 <        assertFalse(r.ran);
4208 <        f.complete(one);
4209 <        checkCompletedNormally(f, one);
4210 <        checkCompletedNormally(g, two);
4211 <        assertTrue(r.ran);
4205 >        /** Implements "monadic plus". */
4206 >        static <T> CompletableFuture<T> plus(CompletableFuture<? extends T> f,
4207 >                                             CompletableFuture<? extends T> g) {
4208 >            PlusFuture<T> plus = new PlusFuture<T>();
4209 >            BiConsumer<T, Throwable> action = (T result, Throwable ex) -> {
4210 >                try {
4211 >                    if (ex == null) {
4212 >                        if (plus.complete(result))
4213 >                            if (plus.firstFailure.get() != null)
4214 >                                plus.firstFailure.set(null);
4215 >                    }
4216 >                    else if (plus.firstFailure.compareAndSet(null, ex)) {
4217 >                        if (plus.isDone())
4218 >                            plus.firstFailure.set(null);
4219 >                    }
4220 >                    else {
4221 >                        // first failure has precedence
4222 >                        Throwable first = plus.firstFailure.getAndSet(null);
4223 >
4224 >                        // may fail with "Self-suppression not permitted"
4225 >                        try { first.addSuppressed(ex); }
4226 >                        catch (Exception ignored) {}
4227 >
4228 >                        plus.completeExceptionally(first);
4229 >                    }
4230 >                } catch (Throwable unexpected) {
4231 >                    plus.completeExceptionally(unexpected);
4232 >                }
4233 >            };
4234 >            f.whenComplete(action);
4235 >            g.whenComplete(action);
4236 >            return plus;
4237 >        }
4238      }
4239  
4240 +    /**
4241 +     * CompletableFuture is an additive monad - sort of.
4242 +     * https://en.wikipedia.org/wiki/Monad_(functional_programming)#Additive_monads
4243 +     */
4244 +    public void testAdditiveMonad() throws Throwable {
4245 +        Function<Long, CompletableFuture<Long>> unit = Monad::unit;
4246 +        CompletableFuture<Long> zero = Monad.zero();
4247 +
4248 +        // Some mutually non-commutative functions
4249 +        Function<Long, CompletableFuture<Long>> triple
4250 +            = x -> Monad.unit(3 * x);
4251 +        Function<Long, CompletableFuture<Long>> inc
4252 +            = x -> Monad.unit(x + 1);
4253 +
4254 +        // unit is a right identity: m >>= unit === m
4255 +        Monad.assertFutureEquals(inc.apply(5L).thenCompose(unit),
4256 +                                 inc.apply(5L));
4257 +        // unit is a left identity: (unit x) >>= f === f x
4258 +        Monad.assertFutureEquals(unit.apply(5L).thenCompose(inc),
4259 +                                 inc.apply(5L));
4260 +
4261 +        // associativity: (m >>= f) >>= g === m >>= ( \x -> (f x >>= g) )
4262 +        Monad.assertFutureEquals(
4263 +            unit.apply(5L).thenCompose(inc).thenCompose(triple),
4264 +            unit.apply(5L).thenCompose(x -> inc.apply(x).thenCompose(triple)));
4265 +
4266 +        // The case for CompletableFuture as an additive monad is weaker...
4267 +
4268 +        // zero is a monadic zero
4269 +        Monad.assertZero(zero);
4270 +
4271 +        // left zero: zero >>= f === zero
4272 +        Monad.assertZero(zero.thenCompose(inc));
4273 +        // right zero: f >>= (\x -> zero) === zero
4274 +        Monad.assertZero(inc.apply(5L).thenCompose(x -> zero));
4275 +
4276 +        // f plus zero === f
4277 +        Monad.assertFutureEquals(Monad.unit(5L),
4278 +                                 Monad.plus(Monad.unit(5L), zero));
4279 +        // zero plus f === f
4280 +        Monad.assertFutureEquals(Monad.unit(5L),
4281 +                                 Monad.plus(zero, Monad.unit(5L)));
4282 +        // zero plus zero === zero
4283 +        Monad.assertZero(Monad.plus(zero, zero));
4284 +        {
4285 +            CompletableFuture<Long> f = Monad.plus(Monad.unit(5L),
4286 +                                                   Monad.unit(8L));
4287 +            // non-determinism
4288 +            assertTrue(f.get() == 5L || f.get() == 8L);
4289 +        }
4290 +
4291 +        CompletableFuture<Long> godot = new CompletableFuture<>();
4292 +        // f plus godot === f (doesn't wait for godot)
4293 +        Monad.assertFutureEquals(Monad.unit(5L),
4294 +                                 Monad.plus(Monad.unit(5L), godot));
4295 +        // godot plus f === f (doesn't wait for godot)
4296 +        Monad.assertFutureEquals(Monad.unit(5L),
4297 +                                 Monad.plus(godot, Monad.unit(5L)));
4298 +    }
4299 +
4300 +    /** Test long recursive chains of CompletableFutures with cascading completions */
4301 +    @SuppressWarnings("FutureReturnValueIgnored")
4302 +    public void testRecursiveChains() throws Throwable {
4303 +        for (ExecutionMode m : ExecutionMode.values())
4304 +        for (boolean addDeadEnds : new boolean[] { true, false })
4305 +    {
4306 +        final int val = 42;
4307 +        final int n = expensiveTests ? 1_000 : 2;
4308 +        CompletableFuture<Integer> head = new CompletableFuture<>();
4309 +        CompletableFuture<Integer> tail = head;
4310 +        for (int i = 0; i < n; i++) {
4311 +            if (addDeadEnds) m.thenApply(tail, v -> v + 1);
4312 +            tail = m.thenApply(tail, v -> v + 1);
4313 +            if (addDeadEnds) m.applyToEither(tail, tail, v -> v + 1);
4314 +            tail = m.applyToEither(tail, tail, v -> v + 1);
4315 +            if (addDeadEnds) m.thenCombine(tail, tail, (v, w) -> v + 1);
4316 +            tail = m.thenCombine(tail, tail, (v, w) -> v + 1);
4317 +        }
4318 +        head.complete(val);
4319 +        assertEquals(val + 3 * n, (int) tail.join());
4320 +    }}
4321 +
4322 +    /**
4323 +     * A single CompletableFuture with many dependents.
4324 +     * A demo of scalability - runtime is O(n).
4325 +     */
4326 +    @SuppressWarnings("FutureReturnValueIgnored")
4327 +    public void testManyDependents() throws Throwable {
4328 +        final int n = expensiveTests ? 1_000_000 : 10;
4329 +        final CompletableFuture<Void> head = new CompletableFuture<>();
4330 +        final CompletableFuture<Void> complete = CompletableFuture.completedFuture((Void)null);
4331 +        final AtomicInteger count = new AtomicInteger(0);
4332 +        for (int i = 0; i < n; i++) {
4333 +            head.thenRun(() -> count.getAndIncrement());
4334 +            head.thenAccept(x -> count.getAndIncrement());
4335 +            head.thenApply(x -> count.getAndIncrement());
4336 +
4337 +            head.runAfterBoth(complete, () -> count.getAndIncrement());
4338 +            head.thenAcceptBoth(complete, (x, y) -> count.getAndIncrement());
4339 +            head.thenCombine(complete, (x, y) -> count.getAndIncrement());
4340 +            complete.runAfterBoth(head, () -> count.getAndIncrement());
4341 +            complete.thenAcceptBoth(head, (x, y) -> count.getAndIncrement());
4342 +            complete.thenCombine(head, (x, y) -> count.getAndIncrement());
4343 +
4344 +            head.runAfterEither(new CompletableFuture<Void>(), () -> count.getAndIncrement());
4345 +            head.acceptEither(new CompletableFuture<Void>(), x -> count.getAndIncrement());
4346 +            head.applyToEither(new CompletableFuture<Void>(), x -> count.getAndIncrement());
4347 +            new CompletableFuture<Void>().runAfterEither(head, () -> count.getAndIncrement());
4348 +            new CompletableFuture<Void>().acceptEither(head, x -> count.getAndIncrement());
4349 +            new CompletableFuture<Void>().applyToEither(head, x -> count.getAndIncrement());
4350 +        }
4351 +        head.complete(null);
4352 +        assertEquals(5 * 3 * n, count.get());
4353 +    }
4354 +
4355 +    /** ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck */
4356 +    @SuppressWarnings("FutureReturnValueIgnored")
4357 +    public void testCoCompletionGarbageRetention() throws Throwable {
4358 +        final int n = expensiveTests ? 1_000_000 : 10;
4359 +        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
4360 +        CompletableFuture<Integer> f;
4361 +        for (int i = 0; i < n; i++) {
4362 +            f = new CompletableFuture<>();
4363 +            f.runAfterEither(incomplete, () -> {});
4364 +            f.complete(null);
4365 +
4366 +            f = new CompletableFuture<>();
4367 +            f.acceptEither(incomplete, x -> {});
4368 +            f.complete(null);
4369 +
4370 +            f = new CompletableFuture<>();
4371 +            f.applyToEither(incomplete, x -> x);
4372 +            f.complete(null);
4373 +
4374 +            f = new CompletableFuture<>();
4375 +            CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
4376 +            f.complete(null);
4377 +        }
4378 +
4379 +        for (int i = 0; i < n; i++) {
4380 +            f = new CompletableFuture<>();
4381 +            incomplete.runAfterEither(f, () -> {});
4382 +            f.complete(null);
4383 +
4384 +            f = new CompletableFuture<>();
4385 +            incomplete.acceptEither(f, x -> {});
4386 +            f.complete(null);
4387 +
4388 +            f = new CompletableFuture<>();
4389 +            incomplete.applyToEither(f, x -> x);
4390 +            f.complete(null);
4391 +
4392 +            f = new CompletableFuture<>();
4393 +            CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
4394 +            f.complete(null);
4395 +        }
4396 +    }
4397 +
4398 +    /**
4399 +     * Reproduction recipe for:
4400 +     * 8160402: Garbage retention with CompletableFuture.anyOf
4401 +     * cvs update -D '2016-05-01' ./src/main/java/util/concurrent/CompletableFuture.java && ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testAnyOfGarbageRetention tck; cvs update -A
4402 +     */
4403 +    public void testAnyOfGarbageRetention() throws Throwable {
4404 +        for (Integer v : new Integer[] { 1, null })
4405 +    {
4406 +        final int n = expensiveTests ? 100_000 : 10;
4407 +        CompletableFuture<Integer>[] fs
4408 +            = (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4409 +        for (int i = 0; i < fs.length; i++)
4410 +            fs[i] = new CompletableFuture<>();
4411 +        fs[fs.length - 1].complete(v);
4412 +        for (int i = 0; i < n; i++)
4413 +            checkCompletedNormally(CompletableFuture.anyOf(fs), v);
4414 +    }}
4415 +
4416 +    /**
4417 +     * Checks for garbage retention with allOf.
4418 +     *
4419 +     * As of 2016-07, fails with OOME:
4420 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testCancelledAllOfGarbageRetention tck
4421 +     */
4422 +    public void testCancelledAllOfGarbageRetention() throws Throwable {
4423 +        final int n = expensiveTests ? 100_000 : 10;
4424 +        CompletableFuture<Integer>[] fs
4425 +            = (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4426 +        for (int i = 0; i < fs.length; i++)
4427 +            fs[i] = new CompletableFuture<>();
4428 +        for (int i = 0; i < n; i++)
4429 +            assertTrue(CompletableFuture.allOf(fs).cancel(false));
4430 +    }
4431 +
4432 +    /**
4433 +     * Checks for garbage retention when a dependent future is
4434 +     * cancelled and garbage-collected.
4435 +     * 8161600: Garbage retention when source CompletableFutures are never completed
4436 +     *
4437 +     * As of 2016-07, fails with OOME:
4438 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testCancelledGarbageRetention tck
4439 +     */
4440 +    public void testCancelledGarbageRetention() throws Throwable {
4441 +        final int n = expensiveTests ? 100_000 : 10;
4442 +        CompletableFuture<Integer> neverCompleted = new CompletableFuture<>();
4443 +        for (int i = 0; i < n; i++)
4444 +            assertTrue(neverCompleted.thenRun(() -> {}).cancel(true));
4445 +    }
4446 +
4447 +    /**
4448 +     * Checks for garbage retention when MinimalStage.toCompletableFuture()
4449 +     * is invoked many times.
4450 +     * 8161600: Garbage retention when source CompletableFutures are never completed
4451 +     *
4452 +     * As of 2016-07, fails with OOME:
4453 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testToCompletableFutureGarbageRetention tck
4454 +     */
4455 +    public void testToCompletableFutureGarbageRetention() throws Throwable {
4456 +        final int n = expensiveTests ? 900_000 : 10;
4457 +        CompletableFuture<Integer> neverCompleted = new CompletableFuture<>();
4458 +        CompletionStage minimal = neverCompleted.minimalCompletionStage();
4459 +        for (int i = 0; i < n; i++)
4460 +            assertTrue(minimal.toCompletableFuture().cancel(true));
4461 +    }
4462 +
4463 + //     static <U> U join(CompletionStage<U> stage) {
4464 + //         CompletableFuture<U> f = new CompletableFuture<>();
4465 + //         stage.whenComplete((v, ex) -> {
4466 + //             if (ex != null) f.completeExceptionally(ex); else f.complete(v);
4467 + //         });
4468 + //         return f.join();
4469 + //     }
4470 +
4471 + //     static <U> boolean isDone(CompletionStage<U> stage) {
4472 + //         CompletableFuture<U> f = new CompletableFuture<>();
4473 + //         stage.whenComplete((v, ex) -> {
4474 + //             if (ex != null) f.completeExceptionally(ex); else f.complete(v);
4475 + //         });
4476 + //         return f.isDone();
4477 + //     }
4478 +
4479 + //     static <U> U join2(CompletionStage<U> stage) {
4480 + //         return stage.toCompletableFuture().copy().join();
4481 + //     }
4482 +
4483 + //     static <U> boolean isDone2(CompletionStage<U> stage) {
4484 + //         return stage.toCompletableFuture().copy().isDone();
4485 + //     }
4486 +
4487   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines